//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_spi(SotoInternal) import SotoCore

extension SESv2 {
    // MARK: Enums

    public enum AttachmentContentDisposition: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case attachment = "ATTACHMENT"
        case inline = "INLINE"
        public var description: String { return self.rawValue }
    }

    public enum AttachmentContentTransferEncoding: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case base64 = "BASE64"
        case quotedPrintable = "QUOTED_PRINTABLE"
        case sevenBit = "SEVEN_BIT"
        public var description: String { return self.rawValue }
    }

    public enum BehaviorOnMxFailure: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case rejectMessage = "REJECT_MESSAGE"
        case useDefaultValue = "USE_DEFAULT_VALUE"
        public var description: String { return self.rawValue }
    }

    public enum BounceType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case permanent = "PERMANENT"
        case transient = "TRANSIENT"
        case undetermined = "UNDETERMINED"
        public var description: String { return self.rawValue }
    }

    public enum BulkEmailStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case accountDailyQuotaExceeded = "ACCOUNT_DAILY_QUOTA_EXCEEDED"
        case accountSendingPaused = "ACCOUNT_SENDING_PAUSED"
        case accountSuspended = "ACCOUNT_SUSPENDED"
        case accountThrottled = "ACCOUNT_THROTTLED"
        case configurationSetNotFound = "CONFIGURATION_SET_NOT_FOUND"
        case configurationSetSendingPaused = "CONFIGURATION_SET_SENDING_PAUSED"
        case failed = "FAILED"
        case invalidParameter = "INVALID_PARAMETER"
        case invalidSendingPoolName = "INVALID_SENDING_POOL_NAME"
        case mailFromDomainNotVerified = "MAIL_FROM_DOMAIN_NOT_VERIFIED"
        case messageRejected = "MESSAGE_REJECTED"
        case success = "SUCCESS"
        case templateNotFound = "TEMPLATE_NOT_FOUND"
        case transientFailure = "TRANSIENT_FAILURE"
        public var description: String { return self.rawValue }
    }

    public enum ContactLanguage: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case en = "EN"
        case ja = "JA"
        public var description: String { return self.rawValue }
    }

    public enum ContactListImportAction: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case delete = "DELETE"
        case put = "PUT"
        public var description: String { return self.rawValue }
    }

    public enum DataFormat: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case csv = "CSV"
        case json = "JSON"
        public var description: String { return self.rawValue }
    }

    public enum DeliverabilityDashboardAccountStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case active = "ACTIVE"
        case disabled = "DISABLED"
        case pendingExpiration = "PENDING_EXPIRATION"
        public var description: String { return self.rawValue }
    }

    public enum DeliverabilityTestStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case completed = "COMPLETED"
        case inProgress = "IN_PROGRESS"
        public var description: String { return self.rawValue }
    }

    public enum DeliveryEventType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case complaint = "COMPLAINT"
        case delivery = "DELIVERY"
        case permanentBounce = "PERMANENT_BOUNCE"
        case send = "SEND"
        case transientBounce = "TRANSIENT_BOUNCE"
        case undeterminedBounce = "UNDETERMINED_BOUNCE"
        public var description: String { return self.rawValue }
    }

    public enum DimensionValueSource: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case emailHeader = "EMAIL_HEADER"
        case linkTag = "LINK_TAG"
        case messageTag = "MESSAGE_TAG"
        public var description: String { return self.rawValue }
    }

    public enum DkimSigningAttributesOrigin: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case awsSes = "AWS_SES"
        case awsSesAfSouth1 = "AWS_SES_AF_SOUTH_1"
        case awsSesApNortheast1 = "AWS_SES_AP_NORTHEAST_1"
        case awsSesApNortheast2 = "AWS_SES_AP_NORTHEAST_2"
        case awsSesApNortheast3 = "AWS_SES_AP_NORTHEAST_3"
        case awsSesApSouth1 = "AWS_SES_AP_SOUTH_1"
        case awsSesApSouth2 = "AWS_SES_AP_SOUTH_2"
        case awsSesApSoutheast1 = "AWS_SES_AP_SOUTHEAST_1"
        case awsSesApSoutheast2 = "AWS_SES_AP_SOUTHEAST_2"
        case awsSesApSoutheast3 = "AWS_SES_AP_SOUTHEAST_3"
        case awsSesCaCentral1 = "AWS_SES_CA_CENTRAL_1"
        case awsSesEuCentral1 = "AWS_SES_EU_CENTRAL_1"
        case awsSesEuCentral2 = "AWS_SES_EU_CENTRAL_2"
        case awsSesEuNorth1 = "AWS_SES_EU_NORTH_1"
        case awsSesEuSouth1 = "AWS_SES_EU_SOUTH_1"
        case awsSesEuWest1 = "AWS_SES_EU_WEST_1"
        case awsSesEuWest2 = "AWS_SES_EU_WEST_2"
        case awsSesEuWest3 = "AWS_SES_EU_WEST_3"
        case awsSesIlCentral1 = "AWS_SES_IL_CENTRAL_1"
        case awsSesMeCentral1 = "AWS_SES_ME_CENTRAL_1"
        case awsSesMeSouth1 = "AWS_SES_ME_SOUTH_1"
        case awsSesSaEast1 = "AWS_SES_SA_EAST_1"
        case awsSesUsEast1 = "AWS_SES_US_EAST_1"
        case awsSesUsEast2 = "AWS_SES_US_EAST_2"
        case awsSesUsWest1 = "AWS_SES_US_WEST_1"
        case awsSesUsWest2 = "AWS_SES_US_WEST_2"
        case external = "EXTERNAL"
        public var description: String { return self.rawValue }
    }

    public enum DkimSigningKeyLength: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case rsa1024Bit = "RSA_1024_BIT"
        case rsa2048Bit = "RSA_2048_BIT"
        public var description: String { return self.rawValue }
    }

    public enum DkimStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case failed = "FAILED"
        case notStarted = "NOT_STARTED"
        case pending = "PENDING"
        case success = "SUCCESS"
        case temporaryFailure = "TEMPORARY_FAILURE"
        public var description: String { return self.rawValue }
    }

    public enum EngagementEventType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case click = "CLICK"
        case open = "OPEN"
        public var description: String { return self.rawValue }
    }

    public enum EventType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case bounce = "BOUNCE"
        case click = "CLICK"
        case complaint = "COMPLAINT"
        case delivery = "DELIVERY"
        case deliveryDelay = "DELIVERY_DELAY"
        case open = "OPEN"
        case reject = "REJECT"
        case renderingFailure = "RENDERING_FAILURE"
        case send = "SEND"
        case subscription = "SUBSCRIPTION"
        public var description: String { return self.rawValue }
    }

    public enum ExportSourceType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case messageInsights = "MESSAGE_INSIGHTS"
        case metricsData = "METRICS_DATA"
        public var description: String { return self.rawValue }
    }

    public enum FeatureStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case disabled = "DISABLED"
        case enabled = "ENABLED"
        public var description: String { return self.rawValue }
    }

    public enum HttpsPolicy: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case optional = "OPTIONAL"
        case require = "REQUIRE"
        case requireOpenOnly = "REQUIRE_OPEN_ONLY"
        public var description: String { return self.rawValue }
    }

    public enum IdentityType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case domain = "DOMAIN"
        case emailAddress = "EMAIL_ADDRESS"
        case managedDomain = "MANAGED_DOMAIN"
        public var description: String { return self.rawValue }
    }

    public enum ImportDestinationType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case contactList = "CONTACT_LIST"
        case suppressionList = "SUPPRESSION_LIST"
        public var description: String { return self.rawValue }
    }

    public enum JobStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case cancelled = "CANCELLED"
        case completed = "COMPLETED"
        case created = "CREATED"
        case failed = "FAILED"
        case processing = "PROCESSING"
        public var description: String { return self.rawValue }
    }

    public enum ListRecommendationsFilterKey: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case impact = "IMPACT"
        case resourceArn = "RESOURCE_ARN"
        case status = "STATUS"
        case type = "TYPE"
        public var description: String { return self.rawValue }
    }

    public enum MailFromDomainStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case failed = "FAILED"
        case pending = "PENDING"
        case success = "SUCCESS"
        case temporaryFailure = "TEMPORARY_FAILURE"
        public var description: String { return self.rawValue }
    }

    public enum MailType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case marketing = "MARKETING"
        case transactional = "TRANSACTIONAL"
        public var description: String { return self.rawValue }
    }

    public enum Metric: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case click = "CLICK"
        case complaint = "COMPLAINT"
        case delivery = "DELIVERY"
        case deliveryClick = "DELIVERY_CLICK"
        case deliveryComplaint = "DELIVERY_COMPLAINT"
        case deliveryOpen = "DELIVERY_OPEN"
        case open = "OPEN"
        case permanentBounce = "PERMANENT_BOUNCE"
        case send = "SEND"
        case transientBounce = "TRANSIENT_BOUNCE"
        public var description: String { return self.rawValue }
    }

    public enum MetricAggregation: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case rate = "RATE"
        case volume = "VOLUME"
        public var description: String { return self.rawValue }
    }

    public enum MetricDimensionName: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case configurationSet = "CONFIGURATION_SET"
        case emailIdentity = "EMAIL_IDENTITY"
        case isp = "ISP"
        public var description: String { return self.rawValue }
    }

    public enum MetricNamespace: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case vdm = "VDM"
        public var description: String { return self.rawValue }
    }

    public enum QueryErrorCode: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case accessDenied = "ACCESS_DENIED"
        case internalFailure = "INTERNAL_FAILURE"
        public var description: String { return self.rawValue }
    }

    public enum RecommendationImpact: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case high = "HIGH"
        case low = "LOW"
        public var description: String { return self.rawValue }
    }

    public enum RecommendationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case fixed = "FIXED"
        case open = "OPEN"
        public var description: String { return self.rawValue }
    }

    public enum RecommendationType: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case bimi = "BIMI"
        case complaint = "COMPLAINT"
        case dkim = "DKIM"
        case dmarc = "DMARC"
        case spf = "SPF"
        public var description: String { return self.rawValue }
    }

    public enum ReviewStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case denied = "DENIED"
        case failed = "FAILED"
        case granted = "GRANTED"
        case pending = "PENDING"
        public var description: String { return self.rawValue }
    }

    public enum ScalingMode: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case managed = "MANAGED"
        case standard = "STANDARD"
        public var description: String { return self.rawValue }
    }

    public enum Status: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case creating = "CREATING"
        case deleting = "DELETING"
        case failed = "FAILED"
        case ready = "READY"
        public var description: String { return self.rawValue }
    }

    public enum SubscriptionStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case optIn = "OPT_IN"
        case optOut = "OPT_OUT"
        public var description: String { return self.rawValue }
    }

    public enum SuppressionListImportAction: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case delete = "DELETE"
        case put = "PUT"
        public var description: String { return self.rawValue }
    }

    public enum SuppressionListReason: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case bounce = "BOUNCE"
        case complaint = "COMPLAINT"
        public var description: String { return self.rawValue }
    }

    public enum TlsPolicy: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case optional = "OPTIONAL"
        case require = "REQUIRE"
        public var description: String { return self.rawValue }
    }

    public enum VerificationError: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case dnsServerError = "DNS_SERVER_ERROR"
        case hostNotFound = "HOST_NOT_FOUND"
        case invalidValue = "INVALID_VALUE"
        case replicationAccessDenied = "REPLICATION_ACCESS_DENIED"
        case replicationPrimaryByoDkimNotSupported = "REPLICATION_PRIMARY_BYO_DKIM_NOT_SUPPORTED"
        case replicationPrimaryInvalidRegion = "REPLICATION_PRIMARY_INVALID_REGION"
        case replicationPrimaryNotFound = "REPLICATION_PRIMARY_NOT_FOUND"
        case replicationReplicaAsPrimaryNotSupported = "REPLICATION_REPLICA_AS_PRIMARY_NOT_SUPPORTED"
        case serviceError = "SERVICE_ERROR"
        case typeNotFound = "TYPE_NOT_FOUND"
        public var description: String { return self.rawValue }
    }

    public enum VerificationStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case failed = "FAILED"
        case notStarted = "NOT_STARTED"
        case pending = "PENDING"
        case success = "SUCCESS"
        case temporaryFailure = "TEMPORARY_FAILURE"
        public var description: String { return self.rawValue }
    }

    public enum WarmupStatus: String, CustomStringConvertible, Codable, Sendable, CodingKeyRepresentable {
        case done = "DONE"
        case inProgress = "IN_PROGRESS"
        case notApplicable = "NOT_APPLICABLE"
        public var description: String { return self.rawValue }
    }

    // MARK: Shapes

    public struct AccountDetails: AWSDecodableShape {
        /// Additional email addresses where updates are sent about your account review process.
        public let additionalContactEmailAddresses: [String]?
        /// The language you would prefer for the case. The contact language can be one of ENGLISH or JAPANESE.
        public let contactLanguage: ContactLanguage?
        /// The type of email your account is sending. The mail type can be one of the following:    MARKETING – Most of your sending traffic is to keep your customers informed of your latest offering.    TRANSACTIONAL – Most of your sending traffic is to communicate during a transaction with a customer.
        public let mailType: MailType?
        /// Information about the review of the latest details you submitted.
        public let reviewDetails: ReviewDetails?
        /// A description of the types of email that you plan to send.
        public let useCaseDescription: String?
        /// The URL of your website. This information helps us better understand the type of content that you plan to send.
        public let websiteURL: String?

        @inlinable
        public init(additionalContactEmailAddresses: [String]? = nil, contactLanguage: ContactLanguage? = nil, mailType: MailType? = nil, reviewDetails: ReviewDetails? = nil, useCaseDescription: String? = nil, websiteURL: String? = nil) {
            self.additionalContactEmailAddresses = additionalContactEmailAddresses
            self.contactLanguage = contactLanguage
            self.mailType = mailType
            self.reviewDetails = reviewDetails
            self.useCaseDescription = useCaseDescription
            self.websiteURL = websiteURL
        }

        private enum CodingKeys: String, CodingKey {
            case additionalContactEmailAddresses = "AdditionalContactEmailAddresses"
            case contactLanguage = "ContactLanguage"
            case mailType = "MailType"
            case reviewDetails = "ReviewDetails"
            case useCaseDescription = "UseCaseDescription"
            case websiteURL = "WebsiteURL"
        }
    }

    public struct ArchivingOptions: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the MailManager archive where the Amazon SES API v2 will archive sent emails.
        public let archiveArn: String?

        @inlinable
        public init(archiveArn: String? = nil) {
            self.archiveArn = archiveArn
        }

        public func validate(name: String) throws {
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, max: 1011)
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, min: 20)
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, pattern: "^arn:(aws|aws-[a-z-]+):ses:[a-z]{2}-[a-z-]+-[0-9]:[0-9]{1,20}:mailmanager-archive/a-[a-z0-9]{24,62}$")
        }

        private enum CodingKeys: String, CodingKey {
            case archiveArn = "ArchiveArn"
        }
    }

    public struct Attachment: AWSEncodableShape {
        ///  A brief description of the attachment content.
        public let contentDescription: String?
        ///  A standard descriptor indicating how the attachment should be rendered in the email. Supported values: ATTACHMENT or INLINE.
        public let contentDisposition: AttachmentContentDisposition?
        ///  Unique identifier for the attachment, used for referencing attachments with INLINE disposition in HTML content.
        public let contentId: String?
        ///  Specifies how the attachment is encoded. Supported values: BASE64, QUOTED_PRINTABLE, SEVEN_BIT.
        public let contentTransferEncoding: AttachmentContentTransferEncoding?
        ///  The MIME type of the attachment.  Example: application/pdf, image/jpeg
        public let contentType: String?
        /// The file name for the attachment as it will appear in the email. Amazon SES restricts certain file extensions. To ensure attachments are accepted, check the Unsupported attachment types in the Amazon SES Developer Guide.
        public let fileName: String
        ///  The raw data of the attachment. It needs to be base64-encoded if you are accessing Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using an Amazon Web Services SDK, the SDK takes care of the base 64-encoding for you.
        public let rawContent: AWSBase64Data

        @inlinable
        public init(contentDescription: String? = nil, contentDisposition: AttachmentContentDisposition? = nil, contentId: String? = nil, contentTransferEncoding: AttachmentContentTransferEncoding? = nil, contentType: String? = nil, fileName: String, rawContent: AWSBase64Data) {
            self.contentDescription = contentDescription
            self.contentDisposition = contentDisposition
            self.contentId = contentId
            self.contentTransferEncoding = contentTransferEncoding
            self.contentType = contentType
            self.fileName = fileName
            self.rawContent = rawContent
        }

        public func validate(name: String) throws {
            try self.validate(self.contentDescription, name: "contentDescription", parent: name, max: 1000)
            try self.validate(self.contentId, name: "contentId", parent: name, max: 78)
            try self.validate(self.contentId, name: "contentId", parent: name, min: 1)
            try self.validate(self.contentType, name: "contentType", parent: name, max: 78)
            try self.validate(self.contentType, name: "contentType", parent: name, min: 1)
            try self.validate(self.fileName, name: "fileName", parent: name, max: 255)
        }

        private enum CodingKeys: String, CodingKey {
            case contentDescription = "ContentDescription"
            case contentDisposition = "ContentDisposition"
            case contentId = "ContentId"
            case contentTransferEncoding = "ContentTransferEncoding"
            case contentType = "ContentType"
            case fileName = "FileName"
            case rawContent = "RawContent"
        }
    }

    public struct BatchGetMetricDataQuery: AWSEncodableShape {
        /// An object that contains mapping between MetricDimensionName and MetricDimensionValue to filter metrics by.
        public let dimensions: [MetricDimensionName: String]?
        /// Represents the end date for the query interval.
        public let endDate: Date
        /// The query identifier.
        public let id: String
        /// The queried metric. This can be one of the following:    SEND – Emails sent eligible for tracking in the VDM dashboard. This excludes emails sent to the mailbox simulator and emails addressed to more than one recipient.    COMPLAINT – Complaints received for your account. This excludes complaints from the mailbox simulator, those originating from your account-level suppression list (if enabled), and those for emails addressed to more than one recipient    PERMANENT_BOUNCE – Permanent bounces - i.e. feedback received for emails sent to non-existent mailboxes. Excludes bounces from the mailbox simulator, those originating from your account-level suppression list (if enabled), and those for emails addressed to more than one recipient.    TRANSIENT_BOUNCE – Transient bounces - i.e. feedback received for delivery failures excluding issues with non-existent mailboxes. Excludes bounces from the mailbox simulator, and those for emails addressed to more than one recipient.    OPEN – Unique open events for emails including open trackers. Excludes opens for emails addressed to more than one recipient.    CLICK – Unique click events for emails including wrapped links. Excludes clicks for emails addressed to more than one recipient.    DELIVERY – Successful deliveries for email sending attempts. Excludes deliveries to the mailbox simulator and for emails addressed to more than one recipient.    DELIVERY_OPEN – Successful deliveries for email sending attempts. Excludes deliveries to the mailbox simulator, for emails addressed to more than one recipient, and emails without open trackers.    DELIVERY_CLICK – Successful deliveries for email sending attempts. Excludes deliveries to the mailbox simulator, for emails addressed to more than one recipient, and emails without click trackers.    DELIVERY_COMPLAINT – Successful deliveries for email sending attempts. Excludes deliveries to the mailbox simulator, for emails addressed to more than one recipient, and emails addressed to recipients hosted by ISPs with which Amazon SES does not have a feedback loop agreement.
        public let metric: Metric
        /// The query namespace - e.g. VDM
        public let namespace: MetricNamespace
        /// Represents the start date for the query interval.
        public let startDate: Date

        @inlinable
        public init(dimensions: [MetricDimensionName: String]? = nil, endDate: Date, id: String, metric: Metric, namespace: MetricNamespace, startDate: Date) {
            self.dimensions = dimensions
            self.endDate = endDate
            self.id = id
            self.metric = metric
            self.namespace = namespace
            self.startDate = startDate
        }

        public func validate(name: String) throws {
            try self.validate(self.dimensions, name: "dimensions", parent: name, max: 3)
            try self.validate(self.dimensions, name: "dimensions", parent: name, min: 1)
            try self.validate(self.id, name: "id", parent: name, max: 255)
            try self.validate(self.id, name: "id", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case dimensions = "Dimensions"
            case endDate = "EndDate"
            case id = "Id"
            case metric = "Metric"
            case namespace = "Namespace"
            case startDate = "StartDate"
        }
    }

    public struct BatchGetMetricDataRequest: AWSEncodableShape {
        /// A list of queries for metrics to be retrieved.
        public let queries: [BatchGetMetricDataQuery]

        @inlinable
        public init(queries: [BatchGetMetricDataQuery]) {
            self.queries = queries
        }

        public func validate(name: String) throws {
            try self.queries.forEach {
                try $0.validate(name: "\(name).queries[]")
            }
            try self.validate(self.queries, name: "queries", parent: name, max: 10)
            try self.validate(self.queries, name: "queries", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case queries = "Queries"
        }
    }

    public struct BatchGetMetricDataResponse: AWSDecodableShape {
        /// A list of MetricDataError encountered while processing your metric data batch request.
        public let errors: [MetricDataError]?
        /// A list of successfully retrieved MetricDataResult.
        public let results: [MetricDataResult]?

        @inlinable
        public init(errors: [MetricDataError]? = nil, results: [MetricDataResult]? = nil) {
            self.errors = errors
            self.results = results
        }

        private enum CodingKeys: String, CodingKey {
            case errors = "Errors"
            case results = "Results"
        }
    }

    public struct BlacklistEntry: AWSDecodableShape {
        /// Additional information about the blacklisting event, as provided by the blacklist maintainer.
        public let description: String?
        /// The time when the blacklisting event occurred.
        public let listingTime: Date?
        /// The name of the blacklist that the IP address appears on.
        public let rblName: String?

        @inlinable
        public init(description: String? = nil, listingTime: Date? = nil, rblName: String? = nil) {
            self.description = description
            self.listingTime = listingTime
            self.rblName = rblName
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case listingTime = "ListingTime"
            case rblName = "RblName"
        }
    }

    public struct Body: AWSEncodableShape {
        /// An object that represents the version of the message that is displayed in email clients that support HTML. HTML messages can include formatted text, hyperlinks, images, and more.
        public let html: Content?
        /// An object that represents the version of the message that is displayed in email clients that don't support HTML, or clients where the recipient has disabled HTML rendering.
        public let text: Content?

        @inlinable
        public init(html: Content? = nil, text: Content? = nil) {
            self.html = html
            self.text = text
        }

        private enum CodingKeys: String, CodingKey {
            case html = "Html"
            case text = "Text"
        }
    }

    public struct Bounce: AWSDecodableShape {
        /// The subtype of the bounce, as determined by SES.
        public let bounceSubType: String?
        /// The type of the bounce, as determined by SES. Can be one of UNDETERMINED, TRANSIENT, or PERMANENT
        public let bounceType: BounceType?
        /// The status code issued by the reporting Message Transfer Authority (MTA). This field only appears if a delivery status notification (DSN) was attached to the bounce and the Diagnostic-Code was provided in the DSN.
        public let diagnosticCode: String?

        @inlinable
        public init(bounceSubType: String? = nil, bounceType: BounceType? = nil, diagnosticCode: String? = nil) {
            self.bounceSubType = bounceSubType
            self.bounceType = bounceType
            self.diagnosticCode = diagnosticCode
        }

        private enum CodingKeys: String, CodingKey {
            case bounceSubType = "BounceSubType"
            case bounceType = "BounceType"
            case diagnosticCode = "DiagnosticCode"
        }
    }

    public struct BulkEmailContent: AWSEncodableShape {
        /// The template to use for the bulk email message.
        public let template: Template?

        @inlinable
        public init(template: Template? = nil) {
            self.template = template
        }

        public func validate(name: String) throws {
            try self.template?.validate(name: "\(name).template")
        }

        private enum CodingKeys: String, CodingKey {
            case template = "Template"
        }
    }

    public struct BulkEmailEntry: AWSEncodableShape {
        /// Represents the destination of the message, consisting of To:, CC:, and BCC: fields.  Amazon SES does not support the SMTPUTF8 extension, as described in RFC6531. For this reason, the local part of a destination email address (the part of the email address that precedes the @ sign) may only contain 7-bit ASCII characters. If the domain part of an address (the part after the @ sign) contains non-ASCII characters, they must be encoded using Punycode, as described in RFC3492.
        public let destination: Destination
        /// The ReplacementEmailContent associated with a BulkEmailEntry.
        public let replacementEmailContent: ReplacementEmailContent?
        /// The list of message headers associated with the BulkEmailEntry data type.   Headers Not Present in BulkEmailEntry: If a header is specified in  Template but not in BulkEmailEntry, the header from Template will be added to the outgoing email.   Headers Present in BulkEmailEntry: If a header is specified in BulkEmailEntry, it takes precedence over any header of the same name specified in  Template :   If the header is also defined within Template, the value from BulkEmailEntry will replace the header's value in the email.   If the header is not defined within Template, it will simply be added to the email as specified in BulkEmailEntry.
        public let replacementHeaders: [MessageHeader]?
        /// A list of tags, in the form of name/value pairs, to apply to an email that you send using the SendBulkTemplatedEmail operation. Tags correspond to characteristics of the email that you define, so that you can publish email sending events.
        public let replacementTags: [MessageTag]?

        @inlinable
        public init(destination: Destination, replacementEmailContent: ReplacementEmailContent? = nil, replacementHeaders: [MessageHeader]? = nil, replacementTags: [MessageTag]? = nil) {
            self.destination = destination
            self.replacementEmailContent = replacementEmailContent
            self.replacementHeaders = replacementHeaders
            self.replacementTags = replacementTags
        }

        public func validate(name: String) throws {
            try self.replacementEmailContent?.validate(name: "\(name).replacementEmailContent")
            try self.replacementHeaders?.forEach {
                try $0.validate(name: "\(name).replacementHeaders[]")
            }
            try self.validate(self.replacementHeaders, name: "replacementHeaders", parent: name, max: 15)
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
            case replacementEmailContent = "ReplacementEmailContent"
            case replacementHeaders = "ReplacementHeaders"
            case replacementTags = "ReplacementTags"
        }
    }

    public struct BulkEmailEntryResult: AWSDecodableShape {
        /// A description of an error that prevented a message being sent using the SendBulkTemplatedEmail operation.
        public let error: String?
        /// The unique message identifier returned from the SendBulkTemplatedEmail operation.
        public let messageId: String?
        /// The status of a message sent using the SendBulkTemplatedEmail operation. Possible values for this parameter include:   SUCCESS: Amazon SES accepted the message, and will attempt to deliver it to the recipients.   MESSAGE_REJECTED: The message was rejected because it contained a virus.   MAIL_FROM_DOMAIN_NOT_VERIFIED: The sender's email address or domain was not verified.   CONFIGURATION_SET_DOES_NOT_EXIST: The configuration set you specified does not exist.   TEMPLATE_DOES_NOT_EXIST: The template you specified does not exist.   ACCOUNT_SUSPENDED: Your account has been shut down because of issues related to your email sending practices.   ACCOUNT_THROTTLED: The number of emails you can send has been reduced because your account has exceeded its allocated sending limit.   ACCOUNT_DAILY_QUOTA_EXCEEDED: You have reached or exceeded the maximum number of emails you can send from your account in a 24-hour period.   INVALID_SENDING_POOL_NAME: The configuration set you specified refers to an IP pool that does not exist.   ACCOUNT_SENDING_PAUSED: Email sending for the Amazon SES account was disabled using the UpdateAccountSendingEnabled operation.   CONFIGURATION_SET_SENDING_PAUSED: Email sending for this configuration set was disabled using the UpdateConfigurationSetSendingEnabled operation.   INVALID_PARAMETER_VALUE: One or more of the parameters you specified when calling this operation was invalid. See the error message for additional information.   TRANSIENT_FAILURE: Amazon SES was unable to process your request because of a temporary issue.   FAILED: Amazon SES was unable to process your request. See the error message for additional information.
        public let status: BulkEmailStatus?

        @inlinable
        public init(error: String? = nil, messageId: String? = nil, status: BulkEmailStatus? = nil) {
            self.error = error
            self.messageId = messageId
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case error = "Error"
            case messageId = "MessageId"
            case status = "Status"
        }
    }

    public struct CancelExportJobRequest: AWSEncodableShape {
        /// The export job ID.
        public let jobId: String

        @inlinable
        public init(jobId: String) {
            self.jobId = jobId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.jobId, key: "JobId")
        }

        public func validate(name: String) throws {
            try self.validate(self.jobId, name: "jobId", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct CancelExportJobResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CloudWatchDestination: AWSEncodableShape & AWSDecodableShape {
        /// An array of objects that define the dimensions to use when you send email events to Amazon CloudWatch.
        public let dimensionConfigurations: [CloudWatchDimensionConfiguration]

        @inlinable
        public init(dimensionConfigurations: [CloudWatchDimensionConfiguration]) {
            self.dimensionConfigurations = dimensionConfigurations
        }

        private enum CodingKeys: String, CodingKey {
            case dimensionConfigurations = "DimensionConfigurations"
        }
    }

    public struct CloudWatchDimensionConfiguration: AWSEncodableShape & AWSDecodableShape {
        /// The default value of the dimension that is published to Amazon CloudWatch if you don't provide the value of the dimension when you send an email. This value has to meet the following criteria:   Can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-), at signs (@), and periods (.).   It can contain no more than 256 characters.
        public let defaultDimensionValue: String
        /// The name of an Amazon CloudWatch dimension associated with an email sending metric. The name has to meet the following criteria:   It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-).   It can contain no more than 256 characters.
        public let dimensionName: String
        /// The location where the Amazon SES API v2 finds the value of a dimension to publish to Amazon CloudWatch. To use the message tags that you specify using an X-SES-MESSAGE-TAGS header or a parameter to the SendEmail or SendRawEmail API, choose messageTag. To use your own email headers, choose emailHeader. To use link tags, choose linkTags.
        public let dimensionValueSource: DimensionValueSource

        @inlinable
        public init(defaultDimensionValue: String, dimensionName: String, dimensionValueSource: DimensionValueSource) {
            self.defaultDimensionValue = defaultDimensionValue
            self.dimensionName = dimensionName
            self.dimensionValueSource = dimensionValueSource
        }

        private enum CodingKeys: String, CodingKey {
            case defaultDimensionValue = "DefaultDimensionValue"
            case dimensionName = "DimensionName"
            case dimensionValueSource = "DimensionValueSource"
        }
    }

    public struct Complaint: AWSDecodableShape {
        ///  The value of the Feedback-Type field from the feedback report received from the ISP.
        public let complaintFeedbackType: String?
        ///  Can either be null or OnAccountSuppressionList. If the value is OnAccountSuppressionList, SES accepted the message, but didn't attempt to send it because it was on the account-level suppression list.
        public let complaintSubType: String?

        @inlinable
        public init(complaintFeedbackType: String? = nil, complaintSubType: String? = nil) {
            self.complaintFeedbackType = complaintFeedbackType
            self.complaintSubType = complaintSubType
        }

        private enum CodingKeys: String, CodingKey {
            case complaintFeedbackType = "ComplaintFeedbackType"
            case complaintSubType = "ComplaintSubType"
        }
    }

    public struct Contact: AWSDecodableShape {
        /// The contact's email address.
        public let emailAddress: String?
        /// A timestamp noting the last time the contact's information was updated.
        public let lastUpdatedTimestamp: Date?
        /// The default topic preferences applied to the contact.
        public let topicDefaultPreferences: [TopicPreference]?
        /// The contact's preference for being opted-in to or opted-out of a topic.
        public let topicPreferences: [TopicPreference]?
        /// A boolean value status noting if the contact is unsubscribed from all contact list topics.
        public let unsubscribeAll: Bool?

        @inlinable
        public init(emailAddress: String? = nil, lastUpdatedTimestamp: Date? = nil, topicDefaultPreferences: [TopicPreference]? = nil, topicPreferences: [TopicPreference]? = nil, unsubscribeAll: Bool? = nil) {
            self.emailAddress = emailAddress
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.topicDefaultPreferences = topicDefaultPreferences
            self.topicPreferences = topicPreferences
            self.unsubscribeAll = unsubscribeAll
        }

        private enum CodingKeys: String, CodingKey {
            case emailAddress = "EmailAddress"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case topicDefaultPreferences = "TopicDefaultPreferences"
            case topicPreferences = "TopicPreferences"
            case unsubscribeAll = "UnsubscribeAll"
        }
    }

    public struct ContactList: AWSDecodableShape {
        /// The name of the contact list.
        public let contactListName: String?
        /// A timestamp noting the last time the contact list was updated.
        public let lastUpdatedTimestamp: Date?

        @inlinable
        public init(contactListName: String? = nil, lastUpdatedTimestamp: Date? = nil) {
            self.contactListName = contactListName
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
        }

        private enum CodingKeys: String, CodingKey {
            case contactListName = "ContactListName"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
        }
    }

    public struct ContactListDestination: AWSEncodableShape & AWSDecodableShape {
        /// >The type of action to perform on the addresses. The following are the possible values:   PUT: add the addresses to the contact list. If the record already exists, it will override it with the new value.   DELETE: remove the addresses from the contact list.
        public let contactListImportAction: ContactListImportAction
        /// The name of the contact list.
        public let contactListName: String

        @inlinable
        public init(contactListImportAction: ContactListImportAction, contactListName: String) {
            self.contactListImportAction = contactListImportAction
            self.contactListName = contactListName
        }

        private enum CodingKeys: String, CodingKey {
            case contactListImportAction = "ContactListImportAction"
            case contactListName = "ContactListName"
        }
    }

    public struct Content: AWSEncodableShape {
        /// The character set for the content. Because of the constraints of the SMTP protocol, Amazon SES uses 7-bit ASCII by default. If the text includes characters outside of the ASCII range, you have to specify a character set. For example, you could specify UTF-8, ISO-8859-1, or Shift_JIS.
        public let charset: String?
        /// The content of the message itself.
        public let data: String

        @inlinable
        public init(charset: String? = nil, data: String) {
            self.charset = charset
            self.data = data
        }

        private enum CodingKeys: String, CodingKey {
            case charset = "Charset"
            case data = "Data"
        }
    }

    public struct CreateConfigurationSetEventDestinationRequest: AWSEncodableShape {
        /// The name of the configuration set .
        public let configurationSetName: String
        /// An object that defines the event destination.
        public let eventDestination: EventDestinationDefinition
        /// A name that identifies the event destination within the configuration set.
        public let eventDestinationName: String

        @inlinable
        public init(configurationSetName: String, eventDestination: EventDestinationDefinition, eventDestinationName: String) {
            self.configurationSetName = configurationSetName
            self.eventDestination = eventDestination
            self.eventDestinationName = eventDestinationName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encode(self.eventDestination, forKey: .eventDestination)
            try container.encode(self.eventDestinationName, forKey: .eventDestinationName)
        }

        private enum CodingKeys: String, CodingKey {
            case eventDestination = "EventDestination"
            case eventDestinationName = "EventDestinationName"
        }
    }

    public struct CreateConfigurationSetEventDestinationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateConfigurationSetRequest: AWSEncodableShape {
        /// An object that defines the MailManager archiving options for emails that you send using the configuration set.
        public let archivingOptions: ArchivingOptions?
        /// The name of the configuration set. The name can contain up to 64 alphanumeric characters, including letters, numbers, hyphens (-) and underscores (_) only.
        public let configurationSetName: String
        /// An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.
        public let deliveryOptions: DeliveryOptions?
        /// An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.
        public let reputationOptions: ReputationOptions?
        /// An object that defines whether or not Amazon SES can send email that you send using the configuration set.
        public let sendingOptions: SendingOptions?
        public let suppressionOptions: SuppressionOptions?
        /// An array of objects that define the tags (keys and values) to associate with the configuration set.
        public let tags: [Tag]?
        /// An object that defines the open and click tracking options for emails that you send using the configuration set.
        public let trackingOptions: TrackingOptions?
        /// An object that defines the VDM options for emails that you send using the configuration set.
        public let vdmOptions: VdmOptions?

        @inlinable
        public init(archivingOptions: ArchivingOptions? = nil, configurationSetName: String, deliveryOptions: DeliveryOptions? = nil, reputationOptions: ReputationOptions? = nil, sendingOptions: SendingOptions? = nil, suppressionOptions: SuppressionOptions? = nil, tags: [Tag]? = nil, trackingOptions: TrackingOptions? = nil, vdmOptions: VdmOptions? = nil) {
            self.archivingOptions = archivingOptions
            self.configurationSetName = configurationSetName
            self.deliveryOptions = deliveryOptions
            self.reputationOptions = reputationOptions
            self.sendingOptions = sendingOptions
            self.suppressionOptions = suppressionOptions
            self.tags = tags
            self.trackingOptions = trackingOptions
            self.vdmOptions = vdmOptions
        }

        public func validate(name: String) throws {
            try self.archivingOptions?.validate(name: "\(name).archivingOptions")
            try self.deliveryOptions?.validate(name: "\(name).deliveryOptions")
        }

        private enum CodingKeys: String, CodingKey {
            case archivingOptions = "ArchivingOptions"
            case configurationSetName = "ConfigurationSetName"
            case deliveryOptions = "DeliveryOptions"
            case reputationOptions = "ReputationOptions"
            case sendingOptions = "SendingOptions"
            case suppressionOptions = "SuppressionOptions"
            case tags = "Tags"
            case trackingOptions = "TrackingOptions"
            case vdmOptions = "VdmOptions"
        }
    }

    public struct CreateConfigurationSetResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateContactListRequest: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String
        /// A description of what the contact list is about.
        public let description: String?
        /// The tags associated with a contact list.
        public let tags: [Tag]?
        /// An interest group, theme, or label within a list. A contact list can have multiple topics.
        public let topics: [Topic]?

        @inlinable
        public init(contactListName: String, description: String? = nil, tags: [Tag]? = nil, topics: [Topic]? = nil) {
            self.contactListName = contactListName
            self.description = description
            self.tags = tags
            self.topics = topics
        }

        private enum CodingKeys: String, CodingKey {
            case contactListName = "ContactListName"
            case description = "Description"
            case tags = "Tags"
            case topics = "Topics"
        }
    }

    public struct CreateContactListResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateContactRequest: AWSEncodableShape {
        /// The attribute data attached to a contact.
        public let attributesData: String?
        /// The name of the contact list to which the contact should be added.
        public let contactListName: String
        /// The contact's email address.
        public let emailAddress: String
        /// The contact's preferences for being opted-in to or opted-out of topics.
        public let topicPreferences: [TopicPreference]?
        /// A boolean value status noting if the contact is unsubscribed from all contact list topics.
        public let unsubscribeAll: Bool?

        @inlinable
        public init(attributesData: String? = nil, contactListName: String, emailAddress: String, topicPreferences: [TopicPreference]? = nil, unsubscribeAll: Bool? = nil) {
            self.attributesData = attributesData
            self.contactListName = contactListName
            self.emailAddress = emailAddress
            self.topicPreferences = topicPreferences
            self.unsubscribeAll = unsubscribeAll
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.attributesData, forKey: .attributesData)
            request.encodePath(self.contactListName, key: "ContactListName")
            try container.encode(self.emailAddress, forKey: .emailAddress)
            try container.encodeIfPresent(self.topicPreferences, forKey: .topicPreferences)
            try container.encodeIfPresent(self.unsubscribeAll, forKey: .unsubscribeAll)
        }

        private enum CodingKeys: String, CodingKey {
            case attributesData = "AttributesData"
            case emailAddress = "EmailAddress"
            case topicPreferences = "TopicPreferences"
            case unsubscribeAll = "UnsubscribeAll"
        }
    }

    public struct CreateContactResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateCustomVerificationEmailTemplateRequest: AWSEncodableShape {
        /// The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.
        public let failureRedirectionURL: String
        /// The email address that the custom verification email is sent from.
        public let fromEmailAddress: String
        /// The URL that the recipient of the verification email is sent to if his or her address is successfully verified.
        public let successRedirectionURL: String
        /// The content of the custom verification email. The total size of the email must be less than 10 MB. The message body may contain HTML, with some limitations. For more information, see Custom verification email frequently asked questions in the Amazon SES Developer Guide.
        public let templateContent: String
        /// The name of the custom verification email template.
        public let templateName: String
        /// The subject line of the custom verification email.
        public let templateSubject: String

        @inlinable
        public init(failureRedirectionURL: String, fromEmailAddress: String, successRedirectionURL: String, templateContent: String, templateName: String, templateSubject: String) {
            self.failureRedirectionURL = failureRedirectionURL
            self.fromEmailAddress = fromEmailAddress
            self.successRedirectionURL = successRedirectionURL
            self.templateContent = templateContent
            self.templateName = templateName
            self.templateSubject = templateSubject
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case failureRedirectionURL = "FailureRedirectionURL"
            case fromEmailAddress = "FromEmailAddress"
            case successRedirectionURL = "SuccessRedirectionURL"
            case templateContent = "TemplateContent"
            case templateName = "TemplateName"
            case templateSubject = "TemplateSubject"
        }
    }

    public struct CreateCustomVerificationEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateDedicatedIpPoolRequest: AWSEncodableShape {
        /// The name of the dedicated IP pool.
        public let poolName: String
        /// The type of scaling mode.
        public let scalingMode: ScalingMode?
        /// An object that defines the tags (keys and values) that you want to associate with the pool.
        public let tags: [Tag]?

        @inlinable
        public init(poolName: String, scalingMode: ScalingMode? = nil, tags: [Tag]? = nil) {
            self.poolName = poolName
            self.scalingMode = scalingMode
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case poolName = "PoolName"
            case scalingMode = "ScalingMode"
            case tags = "Tags"
        }
    }

    public struct CreateDedicatedIpPoolResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateDeliverabilityTestReportRequest: AWSEncodableShape {
        /// The HTML body of the message that you sent when you performed the predictive inbox placement test.
        public let content: EmailContent
        /// The email address that the predictive inbox placement test email was sent from.
        public let fromEmailAddress: String
        /// A unique name that helps you to identify the predictive inbox placement test when you retrieve the results.
        public let reportName: String?
        /// An array of objects that define the tags (keys and values) that you want to associate with the predictive inbox placement test.
        public let tags: [Tag]?

        @inlinable
        public init(content: EmailContent, fromEmailAddress: String, reportName: String? = nil, tags: [Tag]? = nil) {
            self.content = content
            self.fromEmailAddress = fromEmailAddress
            self.reportName = reportName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.content.validate(name: "\(name).content")
        }

        private enum CodingKeys: String, CodingKey {
            case content = "Content"
            case fromEmailAddress = "FromEmailAddress"
            case reportName = "ReportName"
            case tags = "Tags"
        }
    }

    public struct CreateDeliverabilityTestReportResponse: AWSDecodableShape {
        /// The status of the predictive inbox placement test. If the status is IN_PROGRESS, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is COMPLETE, then the test is finished, and you can use the GetDeliverabilityTestReport to view the results of the test.
        public let deliverabilityTestStatus: DeliverabilityTestStatus
        /// A unique string that identifies the predictive inbox placement test.
        public let reportId: String

        @inlinable
        public init(deliverabilityTestStatus: DeliverabilityTestStatus, reportId: String) {
            self.deliverabilityTestStatus = deliverabilityTestStatus
            self.reportId = reportId
        }

        private enum CodingKeys: String, CodingKey {
            case deliverabilityTestStatus = "DeliverabilityTestStatus"
            case reportId = "ReportId"
        }
    }

    public struct CreateEmailIdentityPolicyRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String
        /// The text of the policy in JSON format. The policy cannot exceed 4 KB. For information about the syntax of sending authorization policies, see the Amazon SES Developer Guide.
        public let policy: String
        /// The name of the policy. The policy name cannot exceed 64 characters and can only include alphanumeric characters, dashes, and underscores.
        public let policyName: String

        @inlinable
        public init(emailIdentity: String, policy: String, policyName: String) {
            self.emailIdentity = emailIdentity
            self.policy = policy
            self.policyName = policyName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            try container.encode(self.policy, forKey: .policy)
            request.encodePath(self.policyName, key: "PolicyName")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
            try self.validate(self.policy, name: "policy", parent: name, min: 1)
            try self.validate(self.policyName, name: "policyName", parent: name, max: 64)
            try self.validate(self.policyName, name: "policyName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
        }
    }

    public struct CreateEmailIdentityPolicyResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateEmailIdentityRequest: AWSEncodableShape {
        /// The configuration set to use by default when sending from this identity. Note that any configuration set defined in the email sending request takes precedence.
        public let configurationSetName: String?
        /// If your request includes this object, Amazon SES configures the identity to use Bring Your Own DKIM (BYODKIM) for DKIM authentication purposes, or, configures the key length to be used for Easy DKIM. You can only specify this object if the email identity is a domain, as opposed to an address.
        public let dkimSigningAttributes: DkimSigningAttributes?
        /// The email address or domain to verify.
        public let emailIdentity: String
        /// An array of objects that define the tags (keys and values) to associate with the email identity.
        public let tags: [Tag]?

        @inlinable
        public init(configurationSetName: String? = nil, dkimSigningAttributes: DkimSigningAttributes? = nil, emailIdentity: String, tags: [Tag]? = nil) {
            self.configurationSetName = configurationSetName
            self.dkimSigningAttributes = dkimSigningAttributes
            self.emailIdentity = emailIdentity
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.dkimSigningAttributes?.validate(name: "\(name).dkimSigningAttributes")
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSetName = "ConfigurationSetName"
            case dkimSigningAttributes = "DkimSigningAttributes"
            case emailIdentity = "EmailIdentity"
            case tags = "Tags"
        }
    }

    public struct CreateEmailIdentityResponse: AWSDecodableShape {
        /// An object that contains information about the DKIM attributes for the identity.
        public let dkimAttributes: DkimAttributes?
        /// The email identity type. Note: the MANAGED_DOMAIN identity type is not supported.
        public let identityType: IdentityType?
        /// Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the Amazon Pinpoint User Guide.
        public let verifiedForSendingStatus: Bool?

        @inlinable
        public init(dkimAttributes: DkimAttributes? = nil, identityType: IdentityType? = nil, verifiedForSendingStatus: Bool? = nil) {
            self.dkimAttributes = dkimAttributes
            self.identityType = identityType
            self.verifiedForSendingStatus = verifiedForSendingStatus
        }

        private enum CodingKeys: String, CodingKey {
            case dkimAttributes = "DkimAttributes"
            case identityType = "IdentityType"
            case verifiedForSendingStatus = "VerifiedForSendingStatus"
        }
    }

    public struct CreateEmailTemplateRequest: AWSEncodableShape {
        /// The content of the email template, composed of a subject line, an HTML part, and a text-only part.
        public let templateContent: EmailTemplateContent
        /// The name of the template.
        public let templateName: String

        @inlinable
        public init(templateContent: EmailTemplateContent, templateName: String) {
            self.templateContent = templateContent
            self.templateName = templateName
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case templateContent = "TemplateContent"
            case templateName = "TemplateName"
        }
    }

    public struct CreateEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct CreateExportJobRequest: AWSEncodableShape {
        /// The data source for the export job.
        public let exportDataSource: ExportDataSource
        /// The destination for the export job.
        public let exportDestination: ExportDestination

        @inlinable
        public init(exportDataSource: ExportDataSource, exportDestination: ExportDestination) {
            self.exportDataSource = exportDataSource
            self.exportDestination = exportDestination
        }

        public func validate(name: String) throws {
            try self.exportDataSource.validate(name: "\(name).exportDataSource")
            try self.exportDestination.validate(name: "\(name).exportDestination")
        }

        private enum CodingKeys: String, CodingKey {
            case exportDataSource = "ExportDataSource"
            case exportDestination = "ExportDestination"
        }
    }

    public struct CreateExportJobResponse: AWSDecodableShape {
        /// A string that represents the export job ID.
        public let jobId: String?

        @inlinable
        public init(jobId: String? = nil) {
            self.jobId = jobId
        }

        private enum CodingKeys: String, CodingKey {
            case jobId = "JobId"
        }
    }

    public struct CreateImportJobRequest: AWSEncodableShape {
        /// The data source for the import job.
        public let importDataSource: ImportDataSource
        /// The destination for the import job.
        public let importDestination: ImportDestination

        @inlinable
        public init(importDataSource: ImportDataSource, importDestination: ImportDestination) {
            self.importDataSource = importDataSource
            self.importDestination = importDestination
        }

        public func validate(name: String) throws {
            try self.importDataSource.validate(name: "\(name).importDataSource")
        }

        private enum CodingKeys: String, CodingKey {
            case importDataSource = "ImportDataSource"
            case importDestination = "ImportDestination"
        }
    }

    public struct CreateImportJobResponse: AWSDecodableShape {
        /// A string that represents the import job ID.
        public let jobId: String?

        @inlinable
        public init(jobId: String? = nil) {
            self.jobId = jobId
        }

        private enum CodingKeys: String, CodingKey {
            case jobId = "JobId"
        }
    }

    public struct CreateMultiRegionEndpointRequest: AWSEncodableShape {
        /// Contains details of a multi-region endpoint (global-endpoint) being created.
        public let details: Details
        /// The name of the multi-region endpoint (global-endpoint).
        public let endpointName: String
        /// An array of objects that define the tags (keys and values) to associate with the multi-region endpoint (global-endpoint).
        public let tags: [Tag]?

        @inlinable
        public init(details: Details, endpointName: String, tags: [Tag]? = nil) {
            self.details = details
            self.endpointName = endpointName
            self.tags = tags
        }

        public func validate(name: String) throws {
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 64)
            try self.validate(self.endpointName, name: "endpointName", parent: name, min: 1)
            try self.validate(self.endpointName, name: "endpointName", parent: name, pattern: "^[\\w\\-_]+$")
        }

        private enum CodingKeys: String, CodingKey {
            case details = "Details"
            case endpointName = "EndpointName"
            case tags = "Tags"
        }
    }

    public struct CreateMultiRegionEndpointResponse: AWSDecodableShape {
        /// The ID of the multi-region endpoint (global-endpoint).
        public let endpointId: String?
        /// A status of the multi-region endpoint (global-endpoint) right after the create request.    CREATING – The resource is being provisioned.    READY – The resource is ready to use.    FAILED – The resource failed to be provisioned.    DELETING – The resource is being deleted as requested.
        public let status: Status?

        @inlinable
        public init(endpointId: String? = nil, status: Status? = nil) {
            self.endpointId = endpointId
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case endpointId = "EndpointId"
            case status = "Status"
        }
    }

    public struct CustomVerificationEmailTemplateMetadata: AWSDecodableShape {
        /// The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.
        public let failureRedirectionURL: String?
        /// The email address that the custom verification email is sent from.
        public let fromEmailAddress: String?
        /// The URL that the recipient of the verification email is sent to if his or her address is successfully verified.
        public let successRedirectionURL: String?
        /// The name of the custom verification email template.
        public let templateName: String?
        /// The subject line of the custom verification email.
        public let templateSubject: String?

        @inlinable
        public init(failureRedirectionURL: String? = nil, fromEmailAddress: String? = nil, successRedirectionURL: String? = nil, templateName: String? = nil, templateSubject: String? = nil) {
            self.failureRedirectionURL = failureRedirectionURL
            self.fromEmailAddress = fromEmailAddress
            self.successRedirectionURL = successRedirectionURL
            self.templateName = templateName
            self.templateSubject = templateSubject
        }

        private enum CodingKeys: String, CodingKey {
            case failureRedirectionURL = "FailureRedirectionURL"
            case fromEmailAddress = "FromEmailAddress"
            case successRedirectionURL = "SuccessRedirectionURL"
            case templateName = "TemplateName"
            case templateSubject = "TemplateSubject"
        }
    }

    public struct DailyVolume: AWSDecodableShape {
        /// An object that contains inbox placement metrics for a specified day in the analysis period, broken out by the recipient's email provider.
        public let domainIspPlacements: [DomainIspPlacement]?
        /// The date that the DailyVolume metrics apply to, in Unix time.
        public let startDate: Date?
        /// An object that contains inbox placement metrics for a specific day in the analysis period.
        public let volumeStatistics: VolumeStatistics?

        @inlinable
        public init(domainIspPlacements: [DomainIspPlacement]? = nil, startDate: Date? = nil, volumeStatistics: VolumeStatistics? = nil) {
            self.domainIspPlacements = domainIspPlacements
            self.startDate = startDate
            self.volumeStatistics = volumeStatistics
        }

        private enum CodingKeys: String, CodingKey {
            case domainIspPlacements = "DomainIspPlacements"
            case startDate = "StartDate"
            case volumeStatistics = "VolumeStatistics"
        }
    }

    public struct DashboardAttributes: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the status of your VDM engagement metrics collection. Can be one of the following:    ENABLED – Amazon SES enables engagement metrics for your account.    DISABLED – Amazon SES disables engagement metrics for your account.
        public let engagementMetrics: FeatureStatus?

        @inlinable
        public init(engagementMetrics: FeatureStatus? = nil) {
            self.engagementMetrics = engagementMetrics
        }

        private enum CodingKeys: String, CodingKey {
            case engagementMetrics = "EngagementMetrics"
        }
    }

    public struct DashboardOptions: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the status of your VDM engagement metrics collection. Can be one of the following:    ENABLED – Amazon SES enables engagement metrics for the configuration set.    DISABLED – Amazon SES disables engagement metrics for the configuration set.
        public let engagementMetrics: FeatureStatus?

        @inlinable
        public init(engagementMetrics: FeatureStatus? = nil) {
            self.engagementMetrics = engagementMetrics
        }

        private enum CodingKeys: String, CodingKey {
            case engagementMetrics = "EngagementMetrics"
        }
    }

    public struct DedicatedIp: AWSDecodableShape {
        /// An IPv4 address.
        public let ip: String
        /// The name of the dedicated IP pool that the IP address is associated with.
        public let poolName: String?
        /// Indicates the progress of your dedicated IP warm-up:    0-100 – For standard dedicated IP addresses, this shows the warm-up completion percentage. A value of 100 means the IP address is fully warmed up and ready for use.    -1 – Appears for IP addresses in managed dedicated pools where Amazon SES automatically handles the warm-up process, making the percentage not applicable.
        public let warmupPercentage: Int
        /// The warm-up status of a dedicated IP address. The status can have one of the following values:    IN_PROGRESS – The IP address isn't ready to use because the dedicated IP warm-up process is ongoing.    DONE – The dedicated IP warm-up process is complete, and the IP address is ready to use.    NOT_APPLICABLE – The warm-up status doesn't apply to this IP address. This status is used for IP addresses in managed dedicated IP pools, where Amazon SES automatically handles the warm-up process.
        public let warmupStatus: WarmupStatus

        @inlinable
        public init(ip: String, poolName: String? = nil, warmupPercentage: Int, warmupStatus: WarmupStatus) {
            self.ip = ip
            self.poolName = poolName
            self.warmupPercentage = warmupPercentage
            self.warmupStatus = warmupStatus
        }

        private enum CodingKeys: String, CodingKey {
            case ip = "Ip"
            case poolName = "PoolName"
            case warmupPercentage = "WarmupPercentage"
            case warmupStatus = "WarmupStatus"
        }
    }

    public struct DedicatedIpPool: AWSDecodableShape {
        /// The name of the dedicated IP pool.
        public let poolName: String
        /// The type of the dedicated IP pool.    STANDARD – A dedicated IP pool where you can control which IPs are part of the pool.    MANAGED – A dedicated IP pool where the reputation and number of IPs are automatically managed by Amazon SES.
        public let scalingMode: ScalingMode

        @inlinable
        public init(poolName: String, scalingMode: ScalingMode) {
            self.poolName = poolName
            self.scalingMode = scalingMode
        }

        private enum CodingKeys: String, CodingKey {
            case poolName = "PoolName"
            case scalingMode = "ScalingMode"
        }
    }

    public struct DeleteConfigurationSetEventDestinationRequest: AWSEncodableShape {
        /// The name of the configuration set that contains the event destination to delete.
        public let configurationSetName: String
        /// The name of the event destination to delete.
        public let eventDestinationName: String

        @inlinable
        public init(configurationSetName: String, eventDestinationName: String) {
            self.configurationSetName = configurationSetName
            self.eventDestinationName = eventDestinationName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            request.encodePath(self.eventDestinationName, key: "EventDestinationName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteConfigurationSetEventDestinationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteConfigurationSetRequest: AWSEncodableShape {
        /// The name of the configuration set.
        public let configurationSetName: String

        @inlinable
        public init(configurationSetName: String) {
            self.configurationSetName = configurationSetName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteConfigurationSetResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteContactListRequest: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String

        @inlinable
        public init(contactListName: String) {
            self.contactListName = contactListName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteContactListResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteContactRequest: AWSEncodableShape {
        /// The name of the contact list from which the contact should be removed.
        public let contactListName: String
        /// The contact's email address.
        public let emailAddress: String

        @inlinable
        public init(contactListName: String, emailAddress: String) {
            self.contactListName = contactListName
            self.emailAddress = emailAddress
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
            request.encodePath(self.emailAddress, key: "EmailAddress")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteContactResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteCustomVerificationEmailTemplateRequest: AWSEncodableShape {
        /// The name of the custom verification email template that you want to delete.
        public let templateName: String

        @inlinable
        public init(templateName: String) {
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteCustomVerificationEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteDedicatedIpPoolRequest: AWSEncodableShape {
        /// The name of the dedicated IP pool that you want to delete.
        public let poolName: String

        @inlinable
        public init(poolName: String) {
            self.poolName = poolName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.poolName, key: "PoolName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteDedicatedIpPoolResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteEmailIdentityPolicyRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String
        /// The name of the policy. The policy name cannot exceed 64 characters and can only include alphanumeric characters, dashes, and underscores.
        public let policyName: String

        @inlinable
        public init(emailIdentity: String, policyName: String) {
            self.emailIdentity = emailIdentity
            self.policyName = policyName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            request.encodePath(self.policyName, key: "PolicyName")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
            try self.validate(self.policyName, name: "policyName", parent: name, max: 64)
            try self.validate(self.policyName, name: "policyName", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteEmailIdentityPolicyResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteEmailIdentityRequest: AWSEncodableShape {
        /// The identity (that is, the email address or domain) to delete.
        public let emailIdentity: String

        @inlinable
        public init(emailIdentity: String) {
            self.emailIdentity = emailIdentity
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteEmailIdentityResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteEmailTemplateRequest: AWSEncodableShape {
        /// The name of the template to be deleted.
        public let templateName: String

        @inlinable
        public init(templateName: String) {
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeleteMultiRegionEndpointRequest: AWSEncodableShape {
        /// The name of the multi-region endpoint (global-endpoint) to be deleted.
        public let endpointName: String

        @inlinable
        public init(endpointName: String) {
            self.endpointName = endpointName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.endpointName, key: "EndpointName")
        }

        public func validate(name: String) throws {
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 64)
            try self.validate(self.endpointName, name: "endpointName", parent: name, min: 1)
            try self.validate(self.endpointName, name: "endpointName", parent: name, pattern: "^[\\w\\-_]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteMultiRegionEndpointResponse: AWSDecodableShape {
        /// A status of the multi-region endpoint (global-endpoint) right after the delete request.    CREATING – The resource is being provisioned.    READY – The resource is ready to use.    FAILED – The resource failed to be provisioned.    DELETING – The resource is being deleted as requested.
        public let status: Status?

        @inlinable
        public init(status: Status? = nil) {
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case status = "Status"
        }
    }

    public struct DeleteSuppressedDestinationRequest: AWSEncodableShape {
        /// The suppressed email destination to remove from the account suppression list.
        public let emailAddress: String

        @inlinable
        public init(emailAddress: String) {
            self.emailAddress = emailAddress
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailAddress, key: "EmailAddress")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct DeleteSuppressedDestinationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct DeliverabilityTestReport: AWSDecodableShape {
        /// The date and time when the predictive inbox placement test was created.
        public let createDate: Date?
        /// The status of the predictive inbox placement test. If the status is IN_PROGRESS, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is COMPLETE, then the test is finished, and you can use the GetDeliverabilityTestReport to view the results of the test.
        public let deliverabilityTestStatus: DeliverabilityTestStatus?
        /// The sender address that you specified for the predictive inbox placement test.
        public let fromEmailAddress: String?
        /// A unique string that identifies the predictive inbox placement test.
        public let reportId: String?
        /// A name that helps you identify a predictive inbox placement test report.
        public let reportName: String?
        /// The subject line for an email that you submitted in a predictive inbox placement test.
        public let subject: String?

        @inlinable
        public init(createDate: Date? = nil, deliverabilityTestStatus: DeliverabilityTestStatus? = nil, fromEmailAddress: String? = nil, reportId: String? = nil, reportName: String? = nil, subject: String? = nil) {
            self.createDate = createDate
            self.deliverabilityTestStatus = deliverabilityTestStatus
            self.fromEmailAddress = fromEmailAddress
            self.reportId = reportId
            self.reportName = reportName
            self.subject = subject
        }

        private enum CodingKeys: String, CodingKey {
            case createDate = "CreateDate"
            case deliverabilityTestStatus = "DeliverabilityTestStatus"
            case fromEmailAddress = "FromEmailAddress"
            case reportId = "ReportId"
            case reportName = "ReportName"
            case subject = "Subject"
        }
    }

    public struct DeliveryOptions: AWSEncodableShape & AWSDecodableShape {
        /// The maximum amount of time, in seconds, that Amazon SES API v2 will attempt delivery of email. If specified, the value must greater than or equal to 300 seconds (5 minutes) and less than or equal to 50400 seconds (840 minutes).
        public let maxDeliverySeconds: Int64?
        /// The name of the dedicated IP pool to associate with the configuration set.
        public let sendingPoolName: String?
        /// Specifies whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is Require, messages are only delivered if a TLS connection can be established. If the value is Optional, messages can be delivered in plain text if a TLS connection can't be established.
        public let tlsPolicy: TlsPolicy?

        @inlinable
        public init(maxDeliverySeconds: Int64? = nil, sendingPoolName: String? = nil, tlsPolicy: TlsPolicy? = nil) {
            self.maxDeliverySeconds = maxDeliverySeconds
            self.sendingPoolName = sendingPoolName
            self.tlsPolicy = tlsPolicy
        }

        public func validate(name: String) throws {
            try self.validate(self.maxDeliverySeconds, name: "maxDeliverySeconds", parent: name, max: 50400)
            try self.validate(self.maxDeliverySeconds, name: "maxDeliverySeconds", parent: name, min: 300)
        }

        private enum CodingKeys: String, CodingKey {
            case maxDeliverySeconds = "MaxDeliverySeconds"
            case sendingPoolName = "SendingPoolName"
            case tlsPolicy = "TlsPolicy"
        }
    }

    public struct Destination: AWSEncodableShape {
        /// An array that contains the email addresses of the "BCC" (blind carbon copy) recipients for the email.
        public let bccAddresses: [String]?
        /// An array that contains the email addresses of the "CC" (carbon copy) recipients for the email.
        public let ccAddresses: [String]?
        /// An array that contains the email addresses of the "To" recipients for the email.
        public let toAddresses: [String]?

        @inlinable
        public init(bccAddresses: [String]? = nil, ccAddresses: [String]? = nil, toAddresses: [String]? = nil) {
            self.bccAddresses = bccAddresses
            self.ccAddresses = ccAddresses
            self.toAddresses = toAddresses
        }

        private enum CodingKeys: String, CodingKey {
            case bccAddresses = "BccAddresses"
            case ccAddresses = "CcAddresses"
            case toAddresses = "ToAddresses"
        }
    }

    public struct Details: AWSEncodableShape {
        /// A list of route configuration details. Must contain exactly one route configuration.
        public let routesDetails: [RouteDetails]

        @inlinable
        public init(routesDetails: [RouteDetails]) {
            self.routesDetails = routesDetails
        }

        private enum CodingKeys: String, CodingKey {
            case routesDetails = "RoutesDetails"
        }
    }

    public struct DkimAttributes: AWSDecodableShape {
        /// [Easy DKIM] The key length of the DKIM key pair in use.
        public let currentSigningKeyLength: DkimSigningKeyLength?
        /// [Easy DKIM] The last time a key pair was generated for this identity.
        public let lastKeyGenerationTimestamp: Date?
        /// [Easy DKIM] The key length of the future DKIM key pair to be generated. This can be changed at most once per day.
        public let nextSigningKeyLength: DkimSigningKeyLength?
        /// A string that indicates how DKIM was configured for the identity. These are the possible values:    AWS_SES – Indicates that DKIM was configured for the identity by using Easy DKIM.    EXTERNAL – Indicates that DKIM was configured for the identity by using Bring Your Own DKIM (BYODKIM).    AWS_SES_AF_SOUTH_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Africa (Cape Town) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_NORTH_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Stockholm) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTH_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Mumbai) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTH_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Hyderabad) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_3 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Paris) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (London) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_SOUTH_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Milan) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Ireland) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_3 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Osaka) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Seoul) region using Deterministic Easy-DKIM (DEED).     AWS_SES_ME_CENTRAL_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Middle East (UAE) region using Deterministic Easy-DKIM (DEED).     AWS_SES_ME_SOUTH_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Middle East (Bahrain) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Tokyo) region using Deterministic Easy-DKIM (DEED).     AWS_SES_IL_CENTRAL_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Israel (Tel Aviv) region using Deterministic Easy-DKIM (DEED).     AWS_SES_SA_EAST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in South America (São Paulo) region using Deterministic Easy-DKIM (DEED).     AWS_SES_CA_CENTRAL_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Canada (Central) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Singapore) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Sydney) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_3 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Asia Pacific (Jakarta) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_CENTRAL_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Frankfurt) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_CENTRAL_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in Europe (Zurich) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_EAST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in US East (N. Virginia) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_EAST_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in US East (Ohio) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_WEST_1 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in US West (N. California) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_WEST_2 – Indicates that DKIM was configured for the identity by replicating signing attributes from a parent identity in US West (Oregon) region using Deterministic Easy-DKIM (DEED).
        public let signingAttributesOrigin: DkimSigningAttributesOrigin?
        /// If the value is true, then the messages that you send from the identity are signed using DKIM. If the value is false, then the messages that you send from the identity aren't DKIM-signed.
        public let signingEnabled: Bool?
        /// Describes whether or not Amazon SES has successfully located the DKIM records in the DNS records for the domain. The status can be one of the following:    PENDING – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.    SUCCESS – The verification process completed successfully.    FAILED – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.    TEMPORARY_FAILURE – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.    NOT_STARTED – The DKIM verification process hasn't been initiated for the domain.
        public let status: DkimStatus?
        /// If you used Easy DKIM to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete. If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector for the public key. Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.
        public let tokens: [String]?

        @inlinable
        public init(currentSigningKeyLength: DkimSigningKeyLength? = nil, lastKeyGenerationTimestamp: Date? = nil, nextSigningKeyLength: DkimSigningKeyLength? = nil, signingAttributesOrigin: DkimSigningAttributesOrigin? = nil, signingEnabled: Bool? = nil, status: DkimStatus? = nil, tokens: [String]? = nil) {
            self.currentSigningKeyLength = currentSigningKeyLength
            self.lastKeyGenerationTimestamp = lastKeyGenerationTimestamp
            self.nextSigningKeyLength = nextSigningKeyLength
            self.signingAttributesOrigin = signingAttributesOrigin
            self.signingEnabled = signingEnabled
            self.status = status
            self.tokens = tokens
        }

        private enum CodingKeys: String, CodingKey {
            case currentSigningKeyLength = "CurrentSigningKeyLength"
            case lastKeyGenerationTimestamp = "LastKeyGenerationTimestamp"
            case nextSigningKeyLength = "NextSigningKeyLength"
            case signingAttributesOrigin = "SigningAttributesOrigin"
            case signingEnabled = "SigningEnabled"
            case status = "Status"
            case tokens = "Tokens"
        }
    }

    public struct DkimSigningAttributes: AWSEncodableShape {
        /// The attribute to use for configuring DKIM for the identity depends on the operation:    For PutEmailIdentityDkimSigningAttributes:    None of the values are allowed - use the  SigningAttributesOrigin  parameter instead      For CreateEmailIdentity when replicating a parent identity's DKIM configuration:    Allowed values: All values except AWS_SES and EXTERNAL         AWS_SES – Configure DKIM for the identity by using Easy DKIM.     EXTERNAL – Configure DKIM for the identity by using Bring Your Own DKIM (BYODKIM).     AWS_SES_AF_SOUTH_1 – Configure DKIM for the identity by replicating from a parent identity in Africa (Cape Town) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_NORTH_1 – Configure DKIM for the identity by replicating from a parent identity in Europe (Stockholm) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTH_1 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Mumbai) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTH_2 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Hyderabad) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_3 – Configure DKIM for the identity by replicating from a parent identity in Europe (Paris) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_2 – Configure DKIM for the identity by replicating from a parent identity in Europe (London) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_SOUTH_1 – Configure DKIM for the identity by replicating from a parent identity in Europe (Milan) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_WEST_1 – Configure DKIM for the identity by replicating from a parent identity in Europe (Ireland) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_3 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Osaka) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_2 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Seoul) region using Deterministic Easy-DKIM (DEED).     AWS_SES_ME_CENTRAL_1 – Configure DKIM for the identity by replicating from a parent identity in Middle East (UAE) region using Deterministic Easy-DKIM (DEED).     AWS_SES_ME_SOUTH_1 – Configure DKIM for the identity by replicating from a parent identity in Middle East (Bahrain) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_NORTHEAST_1 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Tokyo) region using Deterministic Easy-DKIM (DEED).     AWS_SES_IL_CENTRAL_1 – Configure DKIM for the identity by replicating from a parent identity in Israel (Tel Aviv) region using Deterministic Easy-DKIM (DEED).     AWS_SES_SA_EAST_1 – Configure DKIM for the identity by replicating from a parent identity in South America (São Paulo) region using Deterministic Easy-DKIM (DEED).     AWS_SES_CA_CENTRAL_1 – Configure DKIM for the identity by replicating from a parent identity in Canada (Central) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_1 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Singapore) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_2 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Sydney) region using Deterministic Easy-DKIM (DEED).     AWS_SES_AP_SOUTHEAST_3 – Configure DKIM for the identity by replicating from a parent identity in Asia Pacific (Jakarta) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_CENTRAL_1 – Configure DKIM for the identity by replicating from a parent identity in Europe (Frankfurt) region using Deterministic Easy-DKIM (DEED).     AWS_SES_EU_CENTRAL_2 – Configure DKIM for the identity by replicating from a parent identity in Europe (Zurich) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_EAST_1 – Configure DKIM for the identity by replicating from a parent identity in US East (N. Virginia) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_EAST_2 – Configure DKIM for the identity by replicating from a parent identity in US East (Ohio) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_WEST_1 – Configure DKIM for the identity by replicating from a parent identity in US West (N. California) region using Deterministic Easy-DKIM (DEED).     AWS_SES_US_WEST_2 – Configure DKIM for the identity by replicating from a parent identity in US West (Oregon) region using Deterministic Easy-DKIM (DEED).
        public let domainSigningAttributesOrigin: DkimSigningAttributesOrigin?
        /// [Bring Your Own DKIM] A private key that's used to generate a DKIM signature. The private key must use 1024 or 2048-bit RSA encryption, and must be encoded using base64 encoding.
        public let domainSigningPrivateKey: String?
        /// [Bring Your Own DKIM] A string that's used to identify a public key in the DNS configuration for a domain.
        public let domainSigningSelector: String?
        /// [Easy DKIM] The key length of the future DKIM key pair to be generated. This can be changed at most once per day.
        public let nextSigningKeyLength: DkimSigningKeyLength?

        @inlinable
        public init(domainSigningAttributesOrigin: DkimSigningAttributesOrigin? = nil, domainSigningPrivateKey: String? = nil, domainSigningSelector: String? = nil, nextSigningKeyLength: DkimSigningKeyLength? = nil) {
            self.domainSigningAttributesOrigin = domainSigningAttributesOrigin
            self.domainSigningPrivateKey = domainSigningPrivateKey
            self.domainSigningSelector = domainSigningSelector
            self.nextSigningKeyLength = nextSigningKeyLength
        }

        public func validate(name: String) throws {
            try self.validate(self.domainSigningPrivateKey, name: "domainSigningPrivateKey", parent: name, max: 20480)
            try self.validate(self.domainSigningPrivateKey, name: "domainSigningPrivateKey", parent: name, min: 1)
            try self.validate(self.domainSigningPrivateKey, name: "domainSigningPrivateKey", parent: name, pattern: "^[a-zA-Z0-9+\\/]+={0,2}$")
            try self.validate(self.domainSigningSelector, name: "domainSigningSelector", parent: name, max: 63)
            try self.validate(self.domainSigningSelector, name: "domainSigningSelector", parent: name, min: 1)
            try self.validate(self.domainSigningSelector, name: "domainSigningSelector", parent: name, pattern: "^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9]))$")
        }

        private enum CodingKeys: String, CodingKey {
            case domainSigningAttributesOrigin = "DomainSigningAttributesOrigin"
            case domainSigningPrivateKey = "DomainSigningPrivateKey"
            case domainSigningSelector = "DomainSigningSelector"
            case nextSigningKeyLength = "NextSigningKeyLength"
        }
    }

    public struct DomainDeliverabilityCampaign: AWSDecodableShape {
        /// The unique identifier for the campaign. The Deliverability dashboard automatically generates and assigns this identifier to a campaign.
        public let campaignId: String?
        /// The percentage of email messages that were deleted by recipients, without being opened first. Due to technical limitations, this value only includes recipients who opened the message by using an email client that supports images.
        public let deleteRate: Double?
        /// The major email providers who handled the email message.
        public let esps: [String]?
        /// The first time when the email message was delivered to any recipient's inbox. This value can help you determine how long it took for a campaign to deliver an email message.
        public let firstSeenDateTime: Date?
        /// The verified email address that the email message was sent from.
        public let fromAddress: String?
        /// The URL of an image that contains a snapshot of the email message that was sent.
        public let imageUrl: String?
        /// The number of email messages that were delivered to recipients’ inboxes.
        public let inboxCount: Int64?
        /// The last time when the email message was delivered to any recipient's inbox. This value can help you determine how long it took for a campaign to deliver an email message.
        public let lastSeenDateTime: Date?
        /// The projected number of recipients that the email message was sent to.
        public let projectedVolume: Int64?
        /// The percentage of email messages that were opened and then deleted by recipients. Due to technical limitations, this value only includes recipients who opened the message by using an email client that supports images.
        public let readDeleteRate: Double?
        /// The percentage of email messages that were opened by recipients. Due to technical limitations, this value only includes recipients who opened the message by using an email client that supports images.
        public let readRate: Double?
        /// The IP addresses that were used to send the email message.
        public let sendingIps: [String]?
        /// The number of email messages that were delivered to recipients' spam or junk mail folders.
        public let spamCount: Int64?
        /// The subject line, or title, of the email message.
        public let subject: String?

        @inlinable
        public init(campaignId: String? = nil, deleteRate: Double? = nil, esps: [String]? = nil, firstSeenDateTime: Date? = nil, fromAddress: String? = nil, imageUrl: String? = nil, inboxCount: Int64? = nil, lastSeenDateTime: Date? = nil, projectedVolume: Int64? = nil, readDeleteRate: Double? = nil, readRate: Double? = nil, sendingIps: [String]? = nil, spamCount: Int64? = nil, subject: String? = nil) {
            self.campaignId = campaignId
            self.deleteRate = deleteRate
            self.esps = esps
            self.firstSeenDateTime = firstSeenDateTime
            self.fromAddress = fromAddress
            self.imageUrl = imageUrl
            self.inboxCount = inboxCount
            self.lastSeenDateTime = lastSeenDateTime
            self.projectedVolume = projectedVolume
            self.readDeleteRate = readDeleteRate
            self.readRate = readRate
            self.sendingIps = sendingIps
            self.spamCount = spamCount
            self.subject = subject
        }

        private enum CodingKeys: String, CodingKey {
            case campaignId = "CampaignId"
            case deleteRate = "DeleteRate"
            case esps = "Esps"
            case firstSeenDateTime = "FirstSeenDateTime"
            case fromAddress = "FromAddress"
            case imageUrl = "ImageUrl"
            case inboxCount = "InboxCount"
            case lastSeenDateTime = "LastSeenDateTime"
            case projectedVolume = "ProjectedVolume"
            case readDeleteRate = "ReadDeleteRate"
            case readRate = "ReadRate"
            case sendingIps = "SendingIps"
            case spamCount = "SpamCount"
            case subject = "Subject"
        }
    }

    public struct DomainDeliverabilityTrackingOption: AWSEncodableShape & AWSDecodableShape {
        /// A verified domain that’s associated with your Amazon Web Services account and currently has an active Deliverability dashboard subscription.
        public let domain: String?
        /// An object that contains information about the inbox placement data settings for the domain.
        public let inboxPlacementTrackingOption: InboxPlacementTrackingOption?
        /// The date when you enabled the Deliverability dashboard for the domain.
        public let subscriptionStartDate: Date?

        @inlinable
        public init(domain: String? = nil, inboxPlacementTrackingOption: InboxPlacementTrackingOption? = nil, subscriptionStartDate: Date? = nil) {
            self.domain = domain
            self.inboxPlacementTrackingOption = inboxPlacementTrackingOption
            self.subscriptionStartDate = subscriptionStartDate
        }

        private enum CodingKeys: String, CodingKey {
            case domain = "Domain"
            case inboxPlacementTrackingOption = "InboxPlacementTrackingOption"
            case subscriptionStartDate = "SubscriptionStartDate"
        }
    }

    public struct DomainIspPlacement: AWSDecodableShape {
        /// The percentage of messages that were sent from the selected domain to the specified email provider that arrived in recipients' inboxes.
        public let inboxPercentage: Double?
        /// The total number of messages that were sent from the selected domain to the specified email provider that arrived in recipients' inboxes.
        public let inboxRawCount: Int64?
        /// The name of the email provider that the inbox placement data applies to.
        public let ispName: String?
        /// The percentage of messages that were sent from the selected domain to the specified email provider that arrived in recipients' spam or junk mail folders.
        public let spamPercentage: Double?
        /// The total number of messages that were sent from the selected domain to the specified email provider that arrived in recipients' spam or junk mail folders.
        public let spamRawCount: Int64?

        @inlinable
        public init(inboxPercentage: Double? = nil, inboxRawCount: Int64? = nil, ispName: String? = nil, spamPercentage: Double? = nil, spamRawCount: Int64? = nil) {
            self.inboxPercentage = inboxPercentage
            self.inboxRawCount = inboxRawCount
            self.ispName = ispName
            self.spamPercentage = spamPercentage
            self.spamRawCount = spamRawCount
        }

        private enum CodingKeys: String, CodingKey {
            case inboxPercentage = "InboxPercentage"
            case inboxRawCount = "InboxRawCount"
            case ispName = "IspName"
            case spamPercentage = "SpamPercentage"
            case spamRawCount = "SpamRawCount"
        }
    }

    public struct EmailContent: AWSEncodableShape {
        /// The raw email message. The message has to meet the following criteria:   The message has to contain a header and a body, separated by one blank line.   All of the required header fields must be present in the message.   Each part of a multipart MIME message must be formatted properly.   If you include attachments, they must be in a file format that the Amazon SES API v2 supports.    The raw data of the message needs to base64-encoded if you are accessing Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using an Amazon Web Services SDK, the SDK takes care of the base 64-encoding for you.   If any of the MIME parts in your message contain content that is outside of the 7-bit ASCII character range, you should encode that content to ensure that recipients' email clients render the message properly.   The length of any single line of text in the message can't exceed 1,000 characters. This restriction is defined in RFC 5321.
        public let raw: RawMessage?
        /// The simple email message. The message consists of a subject, message body and attachments list.
        public let simple: Message?
        /// The template to use for the email message.
        public let template: Template?

        @inlinable
        public init(raw: RawMessage? = nil, simple: Message? = nil, template: Template? = nil) {
            self.raw = raw
            self.simple = simple
            self.template = template
        }

        public func validate(name: String) throws {
            try self.simple?.validate(name: "\(name).simple")
            try self.template?.validate(name: "\(name).template")
        }

        private enum CodingKeys: String, CodingKey {
            case raw = "Raw"
            case simple = "Simple"
            case template = "Template"
        }
    }

    public struct EmailInsights: AWSDecodableShape {
        /// The recipient of the email.
        public let destination: String?
        /// A list of events associated with the sent email.
        public let events: [InsightsEvent]?
        /// The recipient's ISP (e.g., Gmail, Yahoo, etc.).
        public let isp: String?

        @inlinable
        public init(destination: String? = nil, events: [InsightsEvent]? = nil, isp: String? = nil) {
            self.destination = destination
            self.events = events
            self.isp = isp
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
            case events = "Events"
            case isp = "Isp"
        }
    }

    public struct EmailTemplateContent: AWSEncodableShape & AWSDecodableShape {
        /// The HTML body of the email.
        public let html: String?
        /// The subject line of the email.
        public let subject: String?
        /// The email body that will be visible to recipients whose email clients do not display HTML.
        public let text: String?

        @inlinable
        public init(html: String? = nil, subject: String? = nil, text: String? = nil) {
            self.html = html
            self.subject = subject
            self.text = text
        }

        private enum CodingKeys: String, CodingKey {
            case html = "Html"
            case subject = "Subject"
            case text = "Text"
        }
    }

    public struct EmailTemplateMetadata: AWSDecodableShape {
        /// The time and date the template was created.
        public let createdTimestamp: Date?
        /// The name of the template.
        public let templateName: String?

        @inlinable
        public init(createdTimestamp: Date? = nil, templateName: String? = nil) {
            self.createdTimestamp = createdTimestamp
            self.templateName = templateName
        }

        private enum CodingKeys: String, CodingKey {
            case createdTimestamp = "CreatedTimestamp"
            case templateName = "TemplateName"
        }
    }

    public struct EventBridgeDestination: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Amazon EventBridge bus to publish email events to. Only the default bus is supported.
        public let eventBusArn: String

        @inlinable
        public init(eventBusArn: String) {
            self.eventBusArn = eventBusArn
        }

        private enum CodingKeys: String, CodingKey {
            case eventBusArn = "EventBusArn"
        }
    }

    public struct EventDestination: AWSDecodableShape {
        /// An object that defines an Amazon CloudWatch destination for email events. You can use Amazon CloudWatch to monitor and gain insights on your email sending metrics.
        public let cloudWatchDestination: CloudWatchDestination?
        /// If true, the event destination is enabled. When the event destination is enabled, the specified event types are sent to the destinations in this EventDestinationDefinition. If false, the event destination is disabled. When the event destination is disabled, events aren't sent to the specified destinations.
        public let enabled: Bool?
        /// An object that defines an Amazon EventBridge destination for email events. You can use Amazon EventBridge to send notifications when certain email events occur.
        public let eventBridgeDestination: EventBridgeDestination?
        /// An object that defines an Amazon Kinesis Data Firehose destination for email events. You can use Amazon Kinesis Data Firehose to stream data to other services, such as Amazon S3 and Amazon Redshift.
        public let kinesisFirehoseDestination: KinesisFirehoseDestination?
        /// The types of events that Amazon SES sends to the specified event destinations.    SEND - The send request was successful and SES will attempt to deliver the message to the recipient’s mail server. (If account-level or global suppression is being used, SES will still count it as a send, but delivery is suppressed.)    REJECT - SES accepted the email, but determined that it contained a virus and didn’t attempt to deliver it to the recipient’s mail server.    BOUNCE - (Hard bounce) The recipient's mail server permanently rejected the email. (Soft bounces are only included when SES fails to deliver the email after retrying for a period of time.)    COMPLAINT - The email was successfully delivered to the recipient’s mail server, but the recipient marked it as spam.    DELIVERY - SES successfully delivered the email to the recipient's mail server.    OPEN - The recipient received the message and opened it in their email client.    CLICK - The recipient clicked one or more links in the email.    RENDERING_FAILURE - The email wasn't sent because of a template rendering issue. This event type can occur when template data is missing, or when there is a mismatch between template parameters and data. (This event type only occurs when you send email using the  SendEmail or  SendBulkEmail API operations.)     DELIVERY_DELAY - The email couldn't be delivered to the recipient’s mail server because a temporary issue occurred. Delivery delays can occur, for example, when the recipient's inbox is full, or when the receiving email server experiences a transient issue.    SUBSCRIPTION - The email was successfully delivered, but the recipient updated their subscription preferences by clicking on an unsubscribe link as part of your subscription management.
        public let matchingEventTypes: [EventType]
        /// A name that identifies the event destination.
        public let name: String
        /// An object that defines an Amazon Pinpoint project destination for email events. You can send email event data to a Amazon Pinpoint project to view metrics using the Transactional Messaging dashboards that are built in to Amazon Pinpoint. For more information, see Transactional Messaging Charts in the Amazon Pinpoint User Guide.
        public let pinpointDestination: PinpointDestination?
        /// An object that defines an Amazon SNS destination for email events. You can use Amazon SNS to send notifications when certain email events occur.
        public let snsDestination: SnsDestination?

        @inlinable
        public init(cloudWatchDestination: CloudWatchDestination? = nil, enabled: Bool? = nil, eventBridgeDestination: EventBridgeDestination? = nil, kinesisFirehoseDestination: KinesisFirehoseDestination? = nil, matchingEventTypes: [EventType], name: String, pinpointDestination: PinpointDestination? = nil, snsDestination: SnsDestination? = nil) {
            self.cloudWatchDestination = cloudWatchDestination
            self.enabled = enabled
            self.eventBridgeDestination = eventBridgeDestination
            self.kinesisFirehoseDestination = kinesisFirehoseDestination
            self.matchingEventTypes = matchingEventTypes
            self.name = name
            self.pinpointDestination = pinpointDestination
            self.snsDestination = snsDestination
        }

        private enum CodingKeys: String, CodingKey {
            case cloudWatchDestination = "CloudWatchDestination"
            case enabled = "Enabled"
            case eventBridgeDestination = "EventBridgeDestination"
            case kinesisFirehoseDestination = "KinesisFirehoseDestination"
            case matchingEventTypes = "MatchingEventTypes"
            case name = "Name"
            case pinpointDestination = "PinpointDestination"
            case snsDestination = "SnsDestination"
        }
    }

    public struct EventDestinationDefinition: AWSEncodableShape {
        /// An object that defines an Amazon CloudWatch destination for email events. You can use Amazon CloudWatch to monitor and gain insights on your email sending metrics.
        public let cloudWatchDestination: CloudWatchDestination?
        /// If true, the event destination is enabled. When the event destination is enabled, the specified event types are sent to the destinations in this EventDestinationDefinition. If false, the event destination is disabled. When the event destination is disabled, events aren't sent to the specified destinations.
        public let enabled: Bool?
        /// An object that defines an Amazon EventBridge destination for email events. You can use Amazon EventBridge to send notifications when certain email events occur.
        public let eventBridgeDestination: EventBridgeDestination?
        /// An object that defines an Amazon Kinesis Data Firehose destination for email events. You can use Amazon Kinesis Data Firehose to stream data to other services, such as Amazon S3 and Amazon Redshift.
        public let kinesisFirehoseDestination: KinesisFirehoseDestination?
        /// An array that specifies which events the Amazon SES API v2 should send to the destinations in this EventDestinationDefinition.
        public let matchingEventTypes: [EventType]?
        /// An object that defines an Amazon Pinpoint project destination for email events. You can send email event data to a Amazon Pinpoint project to view metrics using the Transactional Messaging dashboards that are built in to Amazon Pinpoint. For more information, see Transactional Messaging Charts in the Amazon Pinpoint User Guide.
        public let pinpointDestination: PinpointDestination?
        /// An object that defines an Amazon SNS destination for email events. You can use Amazon SNS to send notifications when certain email events occur.
        public let snsDestination: SnsDestination?

        @inlinable
        public init(cloudWatchDestination: CloudWatchDestination? = nil, enabled: Bool? = nil, eventBridgeDestination: EventBridgeDestination? = nil, kinesisFirehoseDestination: KinesisFirehoseDestination? = nil, matchingEventTypes: [EventType]? = nil, pinpointDestination: PinpointDestination? = nil, snsDestination: SnsDestination? = nil) {
            self.cloudWatchDestination = cloudWatchDestination
            self.enabled = enabled
            self.eventBridgeDestination = eventBridgeDestination
            self.kinesisFirehoseDestination = kinesisFirehoseDestination
            self.matchingEventTypes = matchingEventTypes
            self.pinpointDestination = pinpointDestination
            self.snsDestination = snsDestination
        }

        private enum CodingKeys: String, CodingKey {
            case cloudWatchDestination = "CloudWatchDestination"
            case enabled = "Enabled"
            case eventBridgeDestination = "EventBridgeDestination"
            case kinesisFirehoseDestination = "KinesisFirehoseDestination"
            case matchingEventTypes = "MatchingEventTypes"
            case pinpointDestination = "PinpointDestination"
            case snsDestination = "SnsDestination"
        }
    }

    public struct EventDetails: AWSDecodableShape {
        /// Information about a Bounce event.
        public let bounce: Bounce?
        /// Information about a Complaint event.
        public let complaint: Complaint?

        @inlinable
        public init(bounce: Bounce? = nil, complaint: Complaint? = nil) {
            self.bounce = bounce
            self.complaint = complaint
        }

        private enum CodingKeys: String, CodingKey {
            case bounce = "Bounce"
            case complaint = "Complaint"
        }
    }

    public struct ExportDataSource: AWSEncodableShape & AWSDecodableShape {
        public let messageInsightsDataSource: MessageInsightsDataSource?
        public let metricsDataSource: MetricsDataSource?

        @inlinable
        public init(messageInsightsDataSource: MessageInsightsDataSource? = nil, metricsDataSource: MetricsDataSource? = nil) {
            self.messageInsightsDataSource = messageInsightsDataSource
            self.metricsDataSource = metricsDataSource
        }

        public func validate(name: String) throws {
            try self.messageInsightsDataSource?.validate(name: "\(name).messageInsightsDataSource")
            try self.metricsDataSource?.validate(name: "\(name).metricsDataSource")
        }

        private enum CodingKeys: String, CodingKey {
            case messageInsightsDataSource = "MessageInsightsDataSource"
            case metricsDataSource = "MetricsDataSource"
        }
    }

    public struct ExportDestination: AWSEncodableShape & AWSDecodableShape {
        /// The data format of the final export job file, can be one of the following:    CSV - A comma-separated values file.    JSON - A Json file.
        public let dataFormat: DataFormat
        /// An Amazon S3 pre-signed URL that points to the generated export file.
        public let s3Url: String?

        @inlinable
        public init(dataFormat: DataFormat, s3Url: String? = nil) {
            self.dataFormat = dataFormat
            self.s3Url = s3Url
        }

        public func validate(name: String) throws {
            try self.validate(self.s3Url, name: "s3Url", parent: name, pattern: "^s3:\\/\\/([^\\/]+)\\/(.*?([^\\/]+)\\/?)$")
        }

        private enum CodingKeys: String, CodingKey {
            case dataFormat = "DataFormat"
            case s3Url = "S3Url"
        }
    }

    public struct ExportJobSummary: AWSDecodableShape {
        /// The timestamp of when the export job was completed.
        public let completedTimestamp: Date?
        /// The timestamp of when the export job was created.
        public let createdTimestamp: Date?
        /// The source type of the export job.
        public let exportSourceType: ExportSourceType?
        /// The export job ID.
        public let jobId: String?
        /// The status of the export job.
        public let jobStatus: JobStatus?

        @inlinable
        public init(completedTimestamp: Date? = nil, createdTimestamp: Date? = nil, exportSourceType: ExportSourceType? = nil, jobId: String? = nil, jobStatus: JobStatus? = nil) {
            self.completedTimestamp = completedTimestamp
            self.createdTimestamp = createdTimestamp
            self.exportSourceType = exportSourceType
            self.jobId = jobId
            self.jobStatus = jobStatus
        }

        private enum CodingKeys: String, CodingKey {
            case completedTimestamp = "CompletedTimestamp"
            case createdTimestamp = "CreatedTimestamp"
            case exportSourceType = "ExportSourceType"
            case jobId = "JobId"
            case jobStatus = "JobStatus"
        }
    }

    public struct ExportMetric: AWSEncodableShape & AWSDecodableShape {
        public let aggregation: MetricAggregation?
        public let name: Metric?

        @inlinable
        public init(aggregation: MetricAggregation? = nil, name: Metric? = nil) {
            self.aggregation = aggregation
            self.name = name
        }

        private enum CodingKeys: String, CodingKey {
            case aggregation = "Aggregation"
            case name = "Name"
        }
    }

    public struct ExportStatistics: AWSDecodableShape {
        /// The number of records that were exported to the final export file. This value might not be available for all export source types
        public let exportedRecordsCount: Int?
        /// The number of records that were processed to generate the final export file.
        public let processedRecordsCount: Int?

        @inlinable
        public init(exportedRecordsCount: Int? = nil, processedRecordsCount: Int? = nil) {
            self.exportedRecordsCount = exportedRecordsCount
            self.processedRecordsCount = processedRecordsCount
        }

        private enum CodingKeys: String, CodingKey {
            case exportedRecordsCount = "ExportedRecordsCount"
            case processedRecordsCount = "ProcessedRecordsCount"
        }
    }

    public struct FailureInfo: AWSDecodableShape {
        /// A message about why the job failed.
        public let errorMessage: String?
        /// An Amazon S3 pre-signed URL that contains all the failed records and related information.
        public let failedRecordsS3Url: String?

        @inlinable
        public init(errorMessage: String? = nil, failedRecordsS3Url: String? = nil) {
            self.errorMessage = errorMessage
            self.failedRecordsS3Url = failedRecordsS3Url
        }

        private enum CodingKeys: String, CodingKey {
            case errorMessage = "ErrorMessage"
            case failedRecordsS3Url = "FailedRecordsS3Url"
        }
    }

    public struct GetAccountRequest: AWSEncodableShape {
        public init() {}
    }

    public struct GetAccountResponse: AWSDecodableShape {
        /// Indicates whether or not the automatic warm-up feature is enabled for dedicated IP addresses that are associated with your account.
        public let dedicatedIpAutoWarmupEnabled: Bool?
        /// An object that defines your account details.
        public let details: AccountDetails?
        /// The reputation status of your Amazon SES account. The status can be one of the following:    HEALTHY – There are no reputation-related issues that currently impact your account.    PROBATION – We've identified potential issues with your Amazon SES account. We're placing your account under review while you work on correcting these issues.    SHUTDOWN – Your account's ability to send email is currently paused because of an issue with the email sent from your account. When you correct the issue, you can contact us and request that your account's ability to send email is resumed.
        public let enforcementStatus: String?
        /// Indicates whether or not your account has production access in the current Amazon Web Services Region. If the value is false, then your account is in the sandbox. When your account is in the sandbox, you can only send email to verified identities.  If the value is true, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.
        public let productionAccessEnabled: Bool?
        /// Indicates whether or not email sending is enabled for your Amazon SES account in the current Amazon Web Services Region.
        public let sendingEnabled: Bool?
        /// An object that contains information about the per-day and per-second sending limits for your Amazon SES account in the current Amazon Web Services Region.
        public let sendQuota: SendQuota?
        /// An object that contains information about the email address suppression preferences for your account in the current Amazon Web Services Region.
        public let suppressionAttributes: SuppressionAttributes?
        /// The VDM attributes that apply to your Amazon SES account.
        public let vdmAttributes: VdmAttributes?

        @inlinable
        public init(dedicatedIpAutoWarmupEnabled: Bool? = nil, details: AccountDetails? = nil, enforcementStatus: String? = nil, productionAccessEnabled: Bool? = nil, sendingEnabled: Bool? = nil, sendQuota: SendQuota? = nil, suppressionAttributes: SuppressionAttributes? = nil, vdmAttributes: VdmAttributes? = nil) {
            self.dedicatedIpAutoWarmupEnabled = dedicatedIpAutoWarmupEnabled
            self.details = details
            self.enforcementStatus = enforcementStatus
            self.productionAccessEnabled = productionAccessEnabled
            self.sendingEnabled = sendingEnabled
            self.sendQuota = sendQuota
            self.suppressionAttributes = suppressionAttributes
            self.vdmAttributes = vdmAttributes
        }

        private enum CodingKeys: String, CodingKey {
            case dedicatedIpAutoWarmupEnabled = "DedicatedIpAutoWarmupEnabled"
            case details = "Details"
            case enforcementStatus = "EnforcementStatus"
            case productionAccessEnabled = "ProductionAccessEnabled"
            case sendingEnabled = "SendingEnabled"
            case sendQuota = "SendQuota"
            case suppressionAttributes = "SuppressionAttributes"
            case vdmAttributes = "VdmAttributes"
        }
    }

    public struct GetBlacklistReportsRequest: AWSEncodableShape {
        /// A list of IP addresses that you want to retrieve blacklist information about. You can only specify the dedicated IP addresses that you use to send email using Amazon SES or Amazon Pinpoint.
        public let blacklistItemNames: [String]

        @inlinable
        public init(blacklistItemNames: [String]) {
            self.blacklistItemNames = blacklistItemNames
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.blacklistItemNames, key: "BlacklistItemNames")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetBlacklistReportsResponse: AWSDecodableShape {
        /// An object that contains information about a blacklist that one of your dedicated IP addresses appears on.
        public let blacklistReport: [String: [BlacklistEntry]]

        @inlinable
        public init(blacklistReport: [String: [BlacklistEntry]]) {
            self.blacklistReport = blacklistReport
        }

        private enum CodingKeys: String, CodingKey {
            case blacklistReport = "BlacklistReport"
        }
    }

    public struct GetConfigurationSetEventDestinationsRequest: AWSEncodableShape {
        /// The name of the configuration set that contains the event destination.
        public let configurationSetName: String

        @inlinable
        public init(configurationSetName: String) {
            self.configurationSetName = configurationSetName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetConfigurationSetEventDestinationsResponse: AWSDecodableShape {
        /// An array that includes all of the events destinations that have been configured for the configuration set.
        public let eventDestinations: [EventDestination]?

        @inlinable
        public init(eventDestinations: [EventDestination]? = nil) {
            self.eventDestinations = eventDestinations
        }

        private enum CodingKeys: String, CodingKey {
            case eventDestinations = "EventDestinations"
        }
    }

    public struct GetConfigurationSetRequest: AWSEncodableShape {
        /// The name of the configuration set.
        public let configurationSetName: String

        @inlinable
        public init(configurationSetName: String) {
            self.configurationSetName = configurationSetName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetConfigurationSetResponse: AWSDecodableShape {
        /// An object that defines the MailManager archive where sent emails are archived that you send using the configuration set.
        public let archivingOptions: ArchivingOptions?
        /// The name of the configuration set.
        public let configurationSetName: String?
        /// An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.
        public let deliveryOptions: DeliveryOptions?
        /// An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.
        public let reputationOptions: ReputationOptions?
        /// An object that defines whether or not Amazon SES can send email that you send using the configuration set.
        public let sendingOptions: SendingOptions?
        /// An object that contains information about the suppression list preferences for your account.
        public let suppressionOptions: SuppressionOptions?
        /// An array of objects that define the tags (keys and values) that are associated with the configuration set.
        public let tags: [Tag]?
        /// An object that defines the open and click tracking options for emails that you send using the configuration set.
        public let trackingOptions: TrackingOptions?
        /// An object that contains information about the VDM preferences for your configuration set.
        public let vdmOptions: VdmOptions?

        @inlinable
        public init(archivingOptions: ArchivingOptions? = nil, configurationSetName: String? = nil, deliveryOptions: DeliveryOptions? = nil, reputationOptions: ReputationOptions? = nil, sendingOptions: SendingOptions? = nil, suppressionOptions: SuppressionOptions? = nil, tags: [Tag]? = nil, trackingOptions: TrackingOptions? = nil, vdmOptions: VdmOptions? = nil) {
            self.archivingOptions = archivingOptions
            self.configurationSetName = configurationSetName
            self.deliveryOptions = deliveryOptions
            self.reputationOptions = reputationOptions
            self.sendingOptions = sendingOptions
            self.suppressionOptions = suppressionOptions
            self.tags = tags
            self.trackingOptions = trackingOptions
            self.vdmOptions = vdmOptions
        }

        private enum CodingKeys: String, CodingKey {
            case archivingOptions = "ArchivingOptions"
            case configurationSetName = "ConfigurationSetName"
            case deliveryOptions = "DeliveryOptions"
            case reputationOptions = "ReputationOptions"
            case sendingOptions = "SendingOptions"
            case suppressionOptions = "SuppressionOptions"
            case tags = "Tags"
            case trackingOptions = "TrackingOptions"
            case vdmOptions = "VdmOptions"
        }
    }

    public struct GetContactListRequest: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String

        @inlinable
        public init(contactListName: String) {
            self.contactListName = contactListName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetContactListResponse: AWSDecodableShape {
        /// The name of the contact list.
        public let contactListName: String?
        /// A timestamp noting when the contact list was created.
        public let createdTimestamp: Date?
        /// A description of what the contact list is about.
        public let description: String?
        /// A timestamp noting the last time the contact list was updated.
        public let lastUpdatedTimestamp: Date?
        /// The tags associated with a contact list.
        public let tags: [Tag]?
        /// An interest group, theme, or label within a list. A contact list can have multiple topics.
        public let topics: [Topic]?

        @inlinable
        public init(contactListName: String? = nil, createdTimestamp: Date? = nil, description: String? = nil, lastUpdatedTimestamp: Date? = nil, tags: [Tag]? = nil, topics: [Topic]? = nil) {
            self.contactListName = contactListName
            self.createdTimestamp = createdTimestamp
            self.description = description
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.tags = tags
            self.topics = topics
        }

        private enum CodingKeys: String, CodingKey {
            case contactListName = "ContactListName"
            case createdTimestamp = "CreatedTimestamp"
            case description = "Description"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case tags = "Tags"
            case topics = "Topics"
        }
    }

    public struct GetContactRequest: AWSEncodableShape {
        /// The name of the contact list to which the contact belongs.
        public let contactListName: String
        /// The contact's email address.
        public let emailAddress: String

        @inlinable
        public init(contactListName: String, emailAddress: String) {
            self.contactListName = contactListName
            self.emailAddress = emailAddress
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
            request.encodePath(self.emailAddress, key: "EmailAddress")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetContactResponse: AWSDecodableShape {
        /// The attribute data attached to a contact.
        public let attributesData: String?
        /// The name of the contact list to which the contact belongs.
        public let contactListName: String?
        /// A timestamp noting when the contact was created.
        public let createdTimestamp: Date?
        /// The contact's email address.
        public let emailAddress: String?
        /// A timestamp noting the last time the contact's information was updated.
        public let lastUpdatedTimestamp: Date?
        /// The default topic preferences applied to the contact.
        public let topicDefaultPreferences: [TopicPreference]?
        /// The contact's preference for being opted-in to or opted-out of a topic.>
        public let topicPreferences: [TopicPreference]?
        /// A boolean value status noting if the contact is unsubscribed from all contact list topics.
        public let unsubscribeAll: Bool?

        @inlinable
        public init(attributesData: String? = nil, contactListName: String? = nil, createdTimestamp: Date? = nil, emailAddress: String? = nil, lastUpdatedTimestamp: Date? = nil, topicDefaultPreferences: [TopicPreference]? = nil, topicPreferences: [TopicPreference]? = nil, unsubscribeAll: Bool? = nil) {
            self.attributesData = attributesData
            self.contactListName = contactListName
            self.createdTimestamp = createdTimestamp
            self.emailAddress = emailAddress
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.topicDefaultPreferences = topicDefaultPreferences
            self.topicPreferences = topicPreferences
            self.unsubscribeAll = unsubscribeAll
        }

        private enum CodingKeys: String, CodingKey {
            case attributesData = "AttributesData"
            case contactListName = "ContactListName"
            case createdTimestamp = "CreatedTimestamp"
            case emailAddress = "EmailAddress"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case topicDefaultPreferences = "TopicDefaultPreferences"
            case topicPreferences = "TopicPreferences"
            case unsubscribeAll = "UnsubscribeAll"
        }
    }

    public struct GetCustomVerificationEmailTemplateRequest: AWSEncodableShape {
        /// The name of the custom verification email template that you want to retrieve.
        public let templateName: String

        @inlinable
        public init(templateName: String) {
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetCustomVerificationEmailTemplateResponse: AWSDecodableShape {
        /// The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.
        public let failureRedirectionURL: String?
        /// The email address that the custom verification email is sent from.
        public let fromEmailAddress: String?
        /// The URL that the recipient of the verification email is sent to if his or her address is successfully verified.
        public let successRedirectionURL: String?
        /// The content of the custom verification email.
        public let templateContent: String?
        /// The name of the custom verification email template.
        public let templateName: String?
        /// The subject line of the custom verification email.
        public let templateSubject: String?

        @inlinable
        public init(failureRedirectionURL: String? = nil, fromEmailAddress: String? = nil, successRedirectionURL: String? = nil, templateContent: String? = nil, templateName: String? = nil, templateSubject: String? = nil) {
            self.failureRedirectionURL = failureRedirectionURL
            self.fromEmailAddress = fromEmailAddress
            self.successRedirectionURL = successRedirectionURL
            self.templateContent = templateContent
            self.templateName = templateName
            self.templateSubject = templateSubject
        }

        private enum CodingKeys: String, CodingKey {
            case failureRedirectionURL = "FailureRedirectionURL"
            case fromEmailAddress = "FromEmailAddress"
            case successRedirectionURL = "SuccessRedirectionURL"
            case templateContent = "TemplateContent"
            case templateName = "TemplateName"
            case templateSubject = "TemplateSubject"
        }
    }

    public struct GetDedicatedIpPoolRequest: AWSEncodableShape {
        /// The name of the dedicated IP pool to retrieve.
        public let poolName: String

        @inlinable
        public init(poolName: String) {
            self.poolName = poolName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.poolName, key: "PoolName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDedicatedIpPoolResponse: AWSDecodableShape {
        /// An object that contains information about a dedicated IP pool.
        public let dedicatedIpPool: DedicatedIpPool?

        @inlinable
        public init(dedicatedIpPool: DedicatedIpPool? = nil) {
            self.dedicatedIpPool = dedicatedIpPool
        }

        private enum CodingKeys: String, CodingKey {
            case dedicatedIpPool = "DedicatedIpPool"
        }
    }

    public struct GetDedicatedIpRequest: AWSEncodableShape {
        /// The IP address that you want to obtain more information about. The value you specify has to be a dedicated IP address that's assocaited with your Amazon Web Services account.
        public let ip: String

        @inlinable
        public init(ip: String) {
            self.ip = ip
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.ip, key: "Ip")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDedicatedIpResponse: AWSDecodableShape {
        /// An object that contains information about a dedicated IP address.
        public let dedicatedIp: DedicatedIp?

        @inlinable
        public init(dedicatedIp: DedicatedIp? = nil) {
            self.dedicatedIp = dedicatedIp
        }

        private enum CodingKeys: String, CodingKey {
            case dedicatedIp = "DedicatedIp"
        }
    }

    public struct GetDedicatedIpsRequest: AWSEncodableShape {
        /// A token returned from a previous call to GetDedicatedIps to indicate the position of the dedicated IP pool in the list of IP pools.
        public let nextToken: String?
        /// The number of results to show in a single call to GetDedicatedIpsRequest. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results.
        public let pageSize: Int?
        /// The name of the IP pool that the dedicated IP address is associated with.
        public let poolName: String?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil, poolName: String? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
            self.poolName = poolName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
            request.encodeQuery(self.poolName, key: "PoolName")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDedicatedIpsResponse: AWSDecodableShape {
        /// A list of dedicated IP addresses that are associated with your Amazon Web Services account.
        public let dedicatedIps: [DedicatedIp]?
        /// A token that indicates that there are additional dedicated IP addresses to list. To view additional addresses, issue another request to GetDedicatedIps, passing this token in the NextToken parameter.
        public let nextToken: String?

        @inlinable
        public init(dedicatedIps: [DedicatedIp]? = nil, nextToken: String? = nil) {
            self.dedicatedIps = dedicatedIps
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case dedicatedIps = "DedicatedIps"
            case nextToken = "NextToken"
        }
    }

    public struct GetDeliverabilityDashboardOptionsRequest: AWSEncodableShape {
        public init() {}
    }

    public struct GetDeliverabilityDashboardOptionsResponse: AWSDecodableShape {
        /// The current status of your Deliverability dashboard subscription. If this value is PENDING_EXPIRATION, your subscription is scheduled to expire at the end of the current calendar month.
        public let accountStatus: DeliverabilityDashboardAccountStatus?
        /// An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that isn’t scheduled to expire at the end of the current calendar month.
        public let activeSubscribedDomains: [DomainDeliverabilityTrackingOption]?
        /// Specifies whether the Deliverability dashboard is enabled. If this value is true, the dashboard is enabled.
        public let dashboardEnabled: Bool
        /// An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that's scheduled to expire at the end of the current calendar month.
        public let pendingExpirationSubscribedDomains: [DomainDeliverabilityTrackingOption]?
        /// The date  when your current subscription to the Deliverability dashboard is scheduled to expire, if your subscription is scheduled to expire at the end of the current calendar month. This value is null if you have an active subscription that isn’t due to expire at the end of the month.
        public let subscriptionExpiryDate: Date?

        @inlinable
        public init(accountStatus: DeliverabilityDashboardAccountStatus? = nil, activeSubscribedDomains: [DomainDeliverabilityTrackingOption]? = nil, dashboardEnabled: Bool, pendingExpirationSubscribedDomains: [DomainDeliverabilityTrackingOption]? = nil, subscriptionExpiryDate: Date? = nil) {
            self.accountStatus = accountStatus
            self.activeSubscribedDomains = activeSubscribedDomains
            self.dashboardEnabled = dashboardEnabled
            self.pendingExpirationSubscribedDomains = pendingExpirationSubscribedDomains
            self.subscriptionExpiryDate = subscriptionExpiryDate
        }

        private enum CodingKeys: String, CodingKey {
            case accountStatus = "AccountStatus"
            case activeSubscribedDomains = "ActiveSubscribedDomains"
            case dashboardEnabled = "DashboardEnabled"
            case pendingExpirationSubscribedDomains = "PendingExpirationSubscribedDomains"
            case subscriptionExpiryDate = "SubscriptionExpiryDate"
        }
    }

    public struct GetDeliverabilityTestReportRequest: AWSEncodableShape {
        /// A unique string that identifies the predictive inbox placement test.
        public let reportId: String

        @inlinable
        public init(reportId: String) {
            self.reportId = reportId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.reportId, key: "ReportId")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDeliverabilityTestReportResponse: AWSDecodableShape {
        /// An object that contains the results of the predictive inbox placement test.
        public let deliverabilityTestReport: DeliverabilityTestReport
        /// An object that describes how the test email was handled by several email providers, including Gmail, Hotmail, Yahoo, AOL, and others.
        public let ispPlacements: [IspPlacement]
        /// An object that contains the message that you sent when you performed this predictive inbox placement test.
        public let message: String?
        /// An object that specifies how many test messages that were sent during the predictive inbox placement test were delivered to recipients' inboxes, how many were sent to recipients' spam folders, and how many weren't delivered.
        public let overallPlacement: PlacementStatistics
        /// An array of objects that define the tags (keys and values) that are associated with the predictive inbox placement test.
        public let tags: [Tag]?

        @inlinable
        public init(deliverabilityTestReport: DeliverabilityTestReport, ispPlacements: [IspPlacement], message: String? = nil, overallPlacement: PlacementStatistics, tags: [Tag]? = nil) {
            self.deliverabilityTestReport = deliverabilityTestReport
            self.ispPlacements = ispPlacements
            self.message = message
            self.overallPlacement = overallPlacement
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case deliverabilityTestReport = "DeliverabilityTestReport"
            case ispPlacements = "IspPlacements"
            case message = "Message"
            case overallPlacement = "OverallPlacement"
            case tags = "Tags"
        }
    }

    public struct GetDomainDeliverabilityCampaignRequest: AWSEncodableShape {
        /// The unique identifier for the campaign. The Deliverability dashboard automatically generates and assigns this identifier to a campaign.
        public let campaignId: String

        @inlinable
        public init(campaignId: String) {
            self.campaignId = campaignId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.campaignId, key: "CampaignId")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDomainDeliverabilityCampaignResponse: AWSDecodableShape {
        /// An object that contains the deliverability data for the campaign.
        public let domainDeliverabilityCampaign: DomainDeliverabilityCampaign

        @inlinable
        public init(domainDeliverabilityCampaign: DomainDeliverabilityCampaign) {
            self.domainDeliverabilityCampaign = domainDeliverabilityCampaign
        }

        private enum CodingKeys: String, CodingKey {
            case domainDeliverabilityCampaign = "DomainDeliverabilityCampaign"
        }
    }

    public struct GetDomainStatisticsReportRequest: AWSEncodableShape {
        /// The domain that you want to obtain deliverability metrics for.
        public let domain: String
        /// The last day (in Unix time) that you want to obtain domain deliverability metrics for. The EndDate that you specify has to be less than or equal to 30 days after the StartDate.
        public let endDate: Date
        /// The first day (in Unix time) that you want to obtain domain deliverability metrics for.
        public let startDate: Date

        @inlinable
        public init(domain: String, endDate: Date, startDate: Date) {
            self.domain = domain
            self.endDate = endDate
            self.startDate = startDate
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.domain, key: "Domain")
            request.encodeQuery(self.endDate, key: "EndDate")
            request.encodeQuery(self.startDate, key: "StartDate")
        }

        public func validate(name: String) throws {
            try self.validate(self.domain, name: "domain", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetDomainStatisticsReportResponse: AWSDecodableShape {
        /// An object that contains deliverability metrics for the domain that you specified. This object contains data for each day, starting on the StartDate and ending on the EndDate.
        public let dailyVolumes: [DailyVolume]
        /// An object that contains deliverability metrics for the domain that you specified. The data in this object is a summary of all of the data that was collected from the StartDate to the EndDate.
        public let overallVolume: OverallVolume

        @inlinable
        public init(dailyVolumes: [DailyVolume], overallVolume: OverallVolume) {
            self.dailyVolumes = dailyVolumes
            self.overallVolume = overallVolume
        }

        private enum CodingKeys: String, CodingKey {
            case dailyVolumes = "DailyVolumes"
            case overallVolume = "OverallVolume"
        }
    }

    public struct GetEmailIdentityPoliciesRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String

        @inlinable
        public init(emailIdentity: String) {
            self.emailIdentity = emailIdentity
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetEmailIdentityPoliciesResponse: AWSDecodableShape {
        /// A map of policy names to policies.
        public let policies: [String: String]?

        @inlinable
        public init(policies: [String: String]? = nil) {
            self.policies = policies
        }

        private enum CodingKeys: String, CodingKey {
            case policies = "Policies"
        }
    }

    public struct GetEmailIdentityRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String

        @inlinable
        public init(emailIdentity: String) {
            self.emailIdentity = emailIdentity
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetEmailIdentityResponse: AWSDecodableShape {
        /// The configuration set used by default when sending from this identity.
        public let configurationSetName: String?
        /// An object that contains information about the DKIM attributes for the identity.
        public let dkimAttributes: DkimAttributes?
        /// The feedback forwarding configuration for the identity. If the value is true, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the Return-Path header of the original email. You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).
        public let feedbackForwardingStatus: Bool?
        /// The email identity type. Note: the MANAGED_DOMAIN identity type is not supported.
        public let identityType: IdentityType?
        /// An object that contains information about the Mail-From attributes for the email identity.
        public let mailFromAttributes: MailFromAttributes?
        /// A map of policy names to policies.
        public let policies: [String: String]?
        /// An array of objects that define the tags (keys and values) that are associated with the email identity.
        public let tags: [Tag]?
        /// An object that contains additional information about the verification status for the identity.
        public let verificationInfo: VerificationInfo?
        /// The verification status of the identity. The status can be one of the following:    PENDING – The verification process was initiated, but Amazon SES hasn't yet been able to verify the identity.    SUCCESS – The verification process completed successfully.    FAILED – The verification process failed.    TEMPORARY_FAILURE – A temporary issue is preventing Amazon SES from determining the verification status of the identity.    NOT_STARTED – The verification process hasn't been initiated for the identity.
        public let verificationStatus: VerificationStatus?
        /// Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the Amazon Pinpoint User Guide.
        public let verifiedForSendingStatus: Bool?

        @inlinable
        public init(configurationSetName: String? = nil, dkimAttributes: DkimAttributes? = nil, feedbackForwardingStatus: Bool? = nil, identityType: IdentityType? = nil, mailFromAttributes: MailFromAttributes? = nil, policies: [String: String]? = nil, tags: [Tag]? = nil, verificationInfo: VerificationInfo? = nil, verificationStatus: VerificationStatus? = nil, verifiedForSendingStatus: Bool? = nil) {
            self.configurationSetName = configurationSetName
            self.dkimAttributes = dkimAttributes
            self.feedbackForwardingStatus = feedbackForwardingStatus
            self.identityType = identityType
            self.mailFromAttributes = mailFromAttributes
            self.policies = policies
            self.tags = tags
            self.verificationInfo = verificationInfo
            self.verificationStatus = verificationStatus
            self.verifiedForSendingStatus = verifiedForSendingStatus
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSetName = "ConfigurationSetName"
            case dkimAttributes = "DkimAttributes"
            case feedbackForwardingStatus = "FeedbackForwardingStatus"
            case identityType = "IdentityType"
            case mailFromAttributes = "MailFromAttributes"
            case policies = "Policies"
            case tags = "Tags"
            case verificationInfo = "VerificationInfo"
            case verificationStatus = "VerificationStatus"
            case verifiedForSendingStatus = "VerifiedForSendingStatus"
        }
    }

    public struct GetEmailTemplateRequest: AWSEncodableShape {
        /// The name of the template.
        public let templateName: String

        @inlinable
        public init(templateName: String) {
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetEmailTemplateResponse: AWSDecodableShape {
        /// The content of the email template, composed of a subject line, an HTML part, and a text-only part.
        public let templateContent: EmailTemplateContent
        /// The name of the template.
        public let templateName: String

        @inlinable
        public init(templateContent: EmailTemplateContent, templateName: String) {
            self.templateContent = templateContent
            self.templateName = templateName
        }

        private enum CodingKeys: String, CodingKey {
            case templateContent = "TemplateContent"
            case templateName = "TemplateName"
        }
    }

    public struct GetExportJobRequest: AWSEncodableShape {
        /// The export job ID.
        public let jobId: String

        @inlinable
        public init(jobId: String) {
            self.jobId = jobId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.jobId, key: "JobId")
        }

        public func validate(name: String) throws {
            try self.validate(self.jobId, name: "jobId", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetExportJobResponse: AWSDecodableShape {
        /// The timestamp of when the export job was completed.
        public let completedTimestamp: Date?
        /// The timestamp of when the export job was created.
        public let createdTimestamp: Date?
        /// The data source of the export job.
        public let exportDataSource: ExportDataSource?
        /// The destination of the export job.
        public let exportDestination: ExportDestination?
        /// The type of source of the export job.
        public let exportSourceType: ExportSourceType?
        /// The failure details about an export job.
        public let failureInfo: FailureInfo?
        /// The export job ID.
        public let jobId: String?
        /// The status of the export job.
        public let jobStatus: JobStatus?
        /// The statistics about the export job.
        public let statistics: ExportStatistics?

        @inlinable
        public init(completedTimestamp: Date? = nil, createdTimestamp: Date? = nil, exportDataSource: ExportDataSource? = nil, exportDestination: ExportDestination? = nil, exportSourceType: ExportSourceType? = nil, failureInfo: FailureInfo? = nil, jobId: String? = nil, jobStatus: JobStatus? = nil, statistics: ExportStatistics? = nil) {
            self.completedTimestamp = completedTimestamp
            self.createdTimestamp = createdTimestamp
            self.exportDataSource = exportDataSource
            self.exportDestination = exportDestination
            self.exportSourceType = exportSourceType
            self.failureInfo = failureInfo
            self.jobId = jobId
            self.jobStatus = jobStatus
            self.statistics = statistics
        }

        private enum CodingKeys: String, CodingKey {
            case completedTimestamp = "CompletedTimestamp"
            case createdTimestamp = "CreatedTimestamp"
            case exportDataSource = "ExportDataSource"
            case exportDestination = "ExportDestination"
            case exportSourceType = "ExportSourceType"
            case failureInfo = "FailureInfo"
            case jobId = "JobId"
            case jobStatus = "JobStatus"
            case statistics = "Statistics"
        }
    }

    public struct GetImportJobRequest: AWSEncodableShape {
        /// The ID of the import job.
        public let jobId: String

        @inlinable
        public init(jobId: String) {
            self.jobId = jobId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.jobId, key: "JobId")
        }

        public func validate(name: String) throws {
            try self.validate(self.jobId, name: "jobId", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetImportJobResponse: AWSDecodableShape {
        /// The time stamp of when the import job was completed.
        public let completedTimestamp: Date?
        /// The time stamp of when the import job was created.
        public let createdTimestamp: Date?
        /// The number of records that failed processing because of invalid input or other reasons.
        public let failedRecordsCount: Int?
        /// The failure details about an import job.
        public let failureInfo: FailureInfo?
        /// The data source of the import job.
        public let importDataSource: ImportDataSource?
        /// The destination of the import job.
        public let importDestination: ImportDestination?
        /// A string that represents the import job ID.
        public let jobId: String?
        /// The status of the import job.
        public let jobStatus: JobStatus?
        /// The current number of records processed.
        public let processedRecordsCount: Int?

        @inlinable
        public init(completedTimestamp: Date? = nil, createdTimestamp: Date? = nil, failedRecordsCount: Int? = nil, failureInfo: FailureInfo? = nil, importDataSource: ImportDataSource? = nil, importDestination: ImportDestination? = nil, jobId: String? = nil, jobStatus: JobStatus? = nil, processedRecordsCount: Int? = nil) {
            self.completedTimestamp = completedTimestamp
            self.createdTimestamp = createdTimestamp
            self.failedRecordsCount = failedRecordsCount
            self.failureInfo = failureInfo
            self.importDataSource = importDataSource
            self.importDestination = importDestination
            self.jobId = jobId
            self.jobStatus = jobStatus
            self.processedRecordsCount = processedRecordsCount
        }

        private enum CodingKeys: String, CodingKey {
            case completedTimestamp = "CompletedTimestamp"
            case createdTimestamp = "CreatedTimestamp"
            case failedRecordsCount = "FailedRecordsCount"
            case failureInfo = "FailureInfo"
            case importDataSource = "ImportDataSource"
            case importDestination = "ImportDestination"
            case jobId = "JobId"
            case jobStatus = "JobStatus"
            case processedRecordsCount = "ProcessedRecordsCount"
        }
    }

    public struct GetMessageInsightsRequest: AWSEncodableShape {
        ///  A MessageId is a unique identifier for a message, and is returned when sending emails through Amazon SES.
        public let messageId: String

        @inlinable
        public init(messageId: String) {
            self.messageId = messageId
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.messageId, key: "MessageId")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetMessageInsightsResponse: AWSDecodableShape {
        ///  A list of tags, in the form of name/value pairs, that were applied to the email you sent, along with Amazon SES Auto-Tags.
        public let emailTags: [MessageTag]?
        /// The from address used to send the message.
        public let fromEmailAddress: String?
        /// A set of insights associated with the message.
        public let insights: [EmailInsights]?
        /// A unique identifier for the message.
        public let messageId: String?
        /// The subject line of the message.
        public let subject: String?

        @inlinable
        public init(emailTags: [MessageTag]? = nil, fromEmailAddress: String? = nil, insights: [EmailInsights]? = nil, messageId: String? = nil, subject: String? = nil) {
            self.emailTags = emailTags
            self.fromEmailAddress = fromEmailAddress
            self.insights = insights
            self.messageId = messageId
            self.subject = subject
        }

        private enum CodingKeys: String, CodingKey {
            case emailTags = "EmailTags"
            case fromEmailAddress = "FromEmailAddress"
            case insights = "Insights"
            case messageId = "MessageId"
            case subject = "Subject"
        }
    }

    public struct GetMultiRegionEndpointRequest: AWSEncodableShape {
        /// The name of the multi-region endpoint (global-endpoint).
        public let endpointName: String

        @inlinable
        public init(endpointName: String) {
            self.endpointName = endpointName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.endpointName, key: "EndpointName")
        }

        public func validate(name: String) throws {
            try self.validate(self.endpointName, name: "endpointName", parent: name, max: 64)
            try self.validate(self.endpointName, name: "endpointName", parent: name, min: 1)
            try self.validate(self.endpointName, name: "endpointName", parent: name, pattern: "^[\\w\\-_]+$")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetMultiRegionEndpointResponse: AWSDecodableShape {
        /// The time stamp of when the multi-region endpoint (global-endpoint) was created.
        public let createdTimestamp: Date?
        /// The ID of the multi-region endpoint (global-endpoint).
        public let endpointId: String?
        /// The name of the multi-region endpoint (global-endpoint).
        public let endpointName: String?
        /// The time stamp of when the multi-region endpoint (global-endpoint) was last updated.
        public let lastUpdatedTimestamp: Date?
        /// Contains routes information for the multi-region endpoint (global-endpoint).
        public let routes: [Route]?
        /// The status of the multi-region endpoint (global-endpoint).    CREATING – The resource is being provisioned.    READY – The resource is ready to use.    FAILED – The resource failed to be provisioned.    DELETING – The resource is being deleted as requested.
        public let status: Status?

        @inlinable
        public init(createdTimestamp: Date? = nil, endpointId: String? = nil, endpointName: String? = nil, lastUpdatedTimestamp: Date? = nil, routes: [Route]? = nil, status: Status? = nil) {
            self.createdTimestamp = createdTimestamp
            self.endpointId = endpointId
            self.endpointName = endpointName
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.routes = routes
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case createdTimestamp = "CreatedTimestamp"
            case endpointId = "EndpointId"
            case endpointName = "EndpointName"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case routes = "Routes"
            case status = "Status"
        }
    }

    public struct GetSuppressedDestinationRequest: AWSEncodableShape {
        /// The email address that's on the account suppression list.
        public let emailAddress: String

        @inlinable
        public init(emailAddress: String) {
            self.emailAddress = emailAddress
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailAddress, key: "EmailAddress")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct GetSuppressedDestinationResponse: AWSDecodableShape {
        /// An object containing information about the suppressed email address.
        public let suppressedDestination: SuppressedDestination

        @inlinable
        public init(suppressedDestination: SuppressedDestination) {
            self.suppressedDestination = suppressedDestination
        }

        private enum CodingKeys: String, CodingKey {
            case suppressedDestination = "SuppressedDestination"
        }
    }

    public struct GuardianAttributes: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the status of your VDM optimized shared delivery. Can be one of the following:    ENABLED – Amazon SES enables optimized shared delivery for your account.    DISABLED – Amazon SES disables optimized shared delivery for your account.
        public let optimizedSharedDelivery: FeatureStatus?

        @inlinable
        public init(optimizedSharedDelivery: FeatureStatus? = nil) {
            self.optimizedSharedDelivery = optimizedSharedDelivery
        }

        private enum CodingKeys: String, CodingKey {
            case optimizedSharedDelivery = "OptimizedSharedDelivery"
        }
    }

    public struct GuardianOptions: AWSEncodableShape & AWSDecodableShape {
        /// Specifies the status of your VDM optimized shared delivery. Can be one of the following:    ENABLED – Amazon SES enables optimized shared delivery for the configuration set.    DISABLED – Amazon SES disables optimized shared delivery for the configuration set.
        public let optimizedSharedDelivery: FeatureStatus?

        @inlinable
        public init(optimizedSharedDelivery: FeatureStatus? = nil) {
            self.optimizedSharedDelivery = optimizedSharedDelivery
        }

        private enum CodingKeys: String, CodingKey {
            case optimizedSharedDelivery = "OptimizedSharedDelivery"
        }
    }

    public struct IdentityInfo: AWSDecodableShape {
        /// The address or domain of the identity.
        public let identityName: String?
        /// The email identity type. Note: the MANAGED_DOMAIN type is not supported for email identity types.
        public let identityType: IdentityType?
        /// Indicates whether or not you can send email from the identity. An identity is an email address or domain that you send email from. Before you can send email from an identity, you have to demostrate that you own the identity, and that you authorize Amazon SES to send email from that identity.
        public let sendingEnabled: Bool?
        /// The verification status of the identity. The status can be one of the following:    PENDING – The verification process was initiated, but Amazon SES hasn't yet been able to verify the identity.    SUCCESS – The verification process completed successfully.    FAILED – The verification process failed.    TEMPORARY_FAILURE – A temporary issue is preventing Amazon SES from determining the verification status of the identity.    NOT_STARTED – The verification process hasn't been initiated for the identity.
        public let verificationStatus: VerificationStatus?

        @inlinable
        public init(identityName: String? = nil, identityType: IdentityType? = nil, sendingEnabled: Bool? = nil, verificationStatus: VerificationStatus? = nil) {
            self.identityName = identityName
            self.identityType = identityType
            self.sendingEnabled = sendingEnabled
            self.verificationStatus = verificationStatus
        }

        private enum CodingKeys: String, CodingKey {
            case identityName = "IdentityName"
            case identityType = "IdentityType"
            case sendingEnabled = "SendingEnabled"
            case verificationStatus = "VerificationStatus"
        }
    }

    public struct ImportDataSource: AWSEncodableShape & AWSDecodableShape {
        /// The data format of the import job's data source.
        public let dataFormat: DataFormat
        /// An Amazon S3 URL in the format s3:///.
        public let s3Url: String

        @inlinable
        public init(dataFormat: DataFormat, s3Url: String) {
            self.dataFormat = dataFormat
            self.s3Url = s3Url
        }

        public func validate(name: String) throws {
            try self.validate(self.s3Url, name: "s3Url", parent: name, pattern: "^s3:\\/\\/([^\\/]+)\\/(.*?([^\\/]+)\\/?)$")
        }

        private enum CodingKeys: String, CodingKey {
            case dataFormat = "DataFormat"
            case s3Url = "S3Url"
        }
    }

    public struct ImportDestination: AWSEncodableShape & AWSDecodableShape {
        /// An object that contains the action of the import job towards a contact list.
        public let contactListDestination: ContactListDestination?
        /// An object that contains the action of the import job towards suppression list.
        public let suppressionListDestination: SuppressionListDestination?

        @inlinable
        public init(contactListDestination: ContactListDestination? = nil, suppressionListDestination: SuppressionListDestination? = nil) {
            self.contactListDestination = contactListDestination
            self.suppressionListDestination = suppressionListDestination
        }

        private enum CodingKeys: String, CodingKey {
            case contactListDestination = "ContactListDestination"
            case suppressionListDestination = "SuppressionListDestination"
        }
    }

    public struct ImportJobSummary: AWSDecodableShape {
        /// The date and time when the import job was created.
        public let createdTimestamp: Date?
        /// The number of records that failed processing because of invalid input or other reasons.
        public let failedRecordsCount: Int?
        public let importDestination: ImportDestination?
        public let jobId: String?
        public let jobStatus: JobStatus?
        /// The current number of records processed.
        public let processedRecordsCount: Int?

        @inlinable
        public init(createdTimestamp: Date? = nil, failedRecordsCount: Int? = nil, importDestination: ImportDestination? = nil, jobId: String? = nil, jobStatus: JobStatus? = nil, processedRecordsCount: Int? = nil) {
            self.createdTimestamp = createdTimestamp
            self.failedRecordsCount = failedRecordsCount
            self.importDestination = importDestination
            self.jobId = jobId
            self.jobStatus = jobStatus
            self.processedRecordsCount = processedRecordsCount
        }

        private enum CodingKeys: String, CodingKey {
            case createdTimestamp = "CreatedTimestamp"
            case failedRecordsCount = "FailedRecordsCount"
            case importDestination = "ImportDestination"
            case jobId = "JobId"
            case jobStatus = "JobStatus"
            case processedRecordsCount = "ProcessedRecordsCount"
        }
    }

    public struct InboxPlacementTrackingOption: AWSEncodableShape & AWSDecodableShape {
        /// Specifies whether inbox placement data is being tracked for the domain.
        public let global: Bool?
        /// An array of strings, one for each major email provider that the inbox placement data applies to.
        public let trackedIsps: [String]?

        @inlinable
        public init(global: Bool? = nil, trackedIsps: [String]? = nil) {
            self.global = global
            self.trackedIsps = trackedIsps
        }

        private enum CodingKeys: String, CodingKey {
            case global = "Global"
            case trackedIsps = "TrackedIsps"
        }
    }

    public struct InsightsEvent: AWSDecodableShape {
        /// Details about bounce or complaint events.
        public let details: EventDetails?
        /// The timestamp of the event.
        public let timestamp: Date?
        /// The type of event:    SEND - The send request was successful and SES will attempt to deliver the message to the recipient’s mail server. (If account-level or global suppression is being used, SES will still count it as a send, but delivery is suppressed.)     DELIVERY - SES successfully delivered the email to the recipient's mail server. Excludes deliveries to the mailbox simulator, and those from emails addressed to more than one recipient.     BOUNCE - Feedback received for delivery failures. Additional details about the bounce are provided in the Details object. Excludes bounces from the mailbox simulator, and those from emails addressed to more than one recipient.     COMPLAINT - Complaint received for the email. Additional details about the complaint are provided in the Details object. This excludes complaints from the mailbox simulator, those originating from your account-level suppression list (if enabled), and those from emails addressed to more than one recipient.     OPEN - Open event for emails including open trackers. Excludes opens for emails addressed to more than one recipient.    CLICK - Click event for emails including wrapped links. Excludes clicks for emails addressed to more than one recipient.
        public let type: EventType?

        @inlinable
        public init(details: EventDetails? = nil, timestamp: Date? = nil, type: EventType? = nil) {
            self.details = details
            self.timestamp = timestamp
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case details = "Details"
            case timestamp = "Timestamp"
            case type = "Type"
        }
    }

    public struct IspPlacement: AWSDecodableShape {
        /// The name of the email provider that the inbox placement data applies to.
        public let ispName: String?
        /// An object that contains inbox placement metrics for a specific email provider.
        public let placementStatistics: PlacementStatistics?

        @inlinable
        public init(ispName: String? = nil, placementStatistics: PlacementStatistics? = nil) {
            self.ispName = ispName
            self.placementStatistics = placementStatistics
        }

        private enum CodingKeys: String, CodingKey {
            case ispName = "IspName"
            case placementStatistics = "PlacementStatistics"
        }
    }

    public struct KinesisFirehoseDestination: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Amazon Kinesis Data Firehose stream that the Amazon SES API v2 sends email events to.
        public let deliveryStreamArn: String
        /// The Amazon Resource Name (ARN) of the IAM role that the Amazon SES API v2 uses to send email events to the Amazon Kinesis Data Firehose stream.
        public let iamRoleArn: String

        @inlinable
        public init(deliveryStreamArn: String, iamRoleArn: String) {
            self.deliveryStreamArn = deliveryStreamArn
            self.iamRoleArn = iamRoleArn
        }

        private enum CodingKeys: String, CodingKey {
            case deliveryStreamArn = "DeliveryStreamArn"
            case iamRoleArn = "IamRoleArn"
        }
    }

    public struct ListConfigurationSetsRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListConfigurationSets to indicate the position in the list of configuration sets.
        public let nextToken: String?
        /// The number of results to show in a single call to ListConfigurationSets. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListConfigurationSetsResponse: AWSDecodableShape {
        /// An array that contains all of the configuration sets in your Amazon SES account in the current Amazon Web Services Region.
        public let configurationSets: [String]?
        /// A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to ListConfigurationSets, and pass this token in the NextToken parameter.
        public let nextToken: String?

        @inlinable
        public init(configurationSets: [String]? = nil, nextToken: String? = nil) {
            self.configurationSets = configurationSets
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSets = "ConfigurationSets"
            case nextToken = "NextToken"
        }
    }

    public struct ListContactListsRequest: AWSEncodableShape {
        /// A string token indicating that there might be additional contact lists available to be listed. Use the token provided in the Response to use in the subsequent call to ListContactLists with the same parameters to retrieve the next page of contact lists.
        public let nextToken: String?
        /// Maximum number of contact lists to return at once. Use this parameter to paginate results. If additional contact lists exist beyond the specified limit, the NextToken element is sent in the response. Use the NextToken value in subsequent requests to retrieve additional lists.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListContactListsResponse: AWSDecodableShape {
        /// The available contact lists.
        public let contactLists: [ContactList]?
        /// A string token indicating that there might be additional contact lists available to be listed. Copy this token to a subsequent call to ListContactLists with the same parameters to retrieve the next page of contact lists.
        public let nextToken: String?

        @inlinable
        public init(contactLists: [ContactList]? = nil, nextToken: String? = nil) {
            self.contactLists = contactLists
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case contactLists = "ContactLists"
            case nextToken = "NextToken"
        }
    }

    public struct ListContactsFilter: AWSEncodableShape {
        /// The status by which you are filtering: OPT_IN or OPT_OUT.
        public let filteredStatus: SubscriptionStatus?
        /// Used for filtering by a specific topic preference.
        public let topicFilter: TopicFilter?

        @inlinable
        public init(filteredStatus: SubscriptionStatus? = nil, topicFilter: TopicFilter? = nil) {
            self.filteredStatus = filteredStatus
            self.topicFilter = topicFilter
        }

        private enum CodingKeys: String, CodingKey {
            case filteredStatus = "FilteredStatus"
            case topicFilter = "TopicFilter"
        }
    }

    public struct ListContactsRequest: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String
        /// A filter that can be applied to a list of contacts.
        public let filter: ListContactsFilter?
        /// A string token indicating that there might be additional contacts available to be listed. Use the token provided in the Response to use in the subsequent call to ListContacts with the same parameters to retrieve the next page of contacts.
        public let nextToken: String?
        /// The number of contacts that may be returned at once, which is dependent on if there are more or less contacts than the value of the PageSize. Use this parameter to paginate results. If additional contacts exist beyond the specified limit, the NextToken element is sent in the response. Use the NextToken value in subsequent requests to retrieve additional contacts.
        public let pageSize: Int?

        @inlinable
        public init(contactListName: String, filter: ListContactsFilter? = nil, nextToken: String? = nil, pageSize: Int? = nil) {
            self.contactListName = contactListName
            self.filter = filter
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
            try container.encodeIfPresent(self.filter, forKey: .filter)
            try container.encodeIfPresent(self.nextToken, forKey: .nextToken)
            try container.encodeIfPresent(self.pageSize, forKey: .pageSize)
        }

        private enum CodingKeys: String, CodingKey {
            case filter = "Filter"
            case nextToken = "NextToken"
            case pageSize = "PageSize"
        }
    }

    public struct ListContactsResponse: AWSDecodableShape {
        /// The contacts present in a specific contact list.
        public let contacts: [Contact]?
        /// A string token indicating that there might be additional contacts available to be listed. Copy this token to a subsequent call to ListContacts with the same parameters to retrieve the next page of contacts.
        public let nextToken: String?

        @inlinable
        public init(contacts: [Contact]? = nil, nextToken: String? = nil) {
            self.contacts = contacts
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case contacts = "Contacts"
            case nextToken = "NextToken"
        }
    }

    public struct ListCustomVerificationEmailTemplatesRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListCustomVerificationEmailTemplates to indicate the position in the list of custom verification email templates.
        public let nextToken: String?
        /// The number of results to show in a single call to ListCustomVerificationEmailTemplates. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results. The value you specify has to be at least 1, and can be no more than 50.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListCustomVerificationEmailTemplatesResponse: AWSDecodableShape {
        /// A list of the custom verification email templates that exist in your account.
        public let customVerificationEmailTemplates: [CustomVerificationEmailTemplateMetadata]?
        /// A token indicating that there are additional custom verification email templates available to be listed. Pass this token to a subsequent call to ListCustomVerificationEmailTemplates to retrieve the next 50 custom verification email templates.
        public let nextToken: String?

        @inlinable
        public init(customVerificationEmailTemplates: [CustomVerificationEmailTemplateMetadata]? = nil, nextToken: String? = nil) {
            self.customVerificationEmailTemplates = customVerificationEmailTemplates
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case customVerificationEmailTemplates = "CustomVerificationEmailTemplates"
            case nextToken = "NextToken"
        }
    }

    public struct ListDedicatedIpPoolsRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListDedicatedIpPools to indicate the position in the list of dedicated IP pools.
        public let nextToken: String?
        /// The number of results to show in a single call to ListDedicatedIpPools. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListDedicatedIpPoolsResponse: AWSDecodableShape {
        /// A list of all of the dedicated IP pools that are associated with your Amazon Web Services account in the current Region.
        public let dedicatedIpPools: [String]?
        /// A token that indicates that there are additional IP pools to list. To view additional IP pools, issue another request to ListDedicatedIpPools, passing this token in the NextToken parameter.
        public let nextToken: String?

        @inlinable
        public init(dedicatedIpPools: [String]? = nil, nextToken: String? = nil) {
            self.dedicatedIpPools = dedicatedIpPools
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case dedicatedIpPools = "DedicatedIpPools"
            case nextToken = "NextToken"
        }
    }

    public struct ListDeliverabilityTestReportsRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListDeliverabilityTestReports to indicate the position in the list of predictive inbox placement tests.
        public let nextToken: String?
        /// The number of results to show in a single call to ListDeliverabilityTestReports. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results. The value you specify has to be at least 0, and can be no more than 1000.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListDeliverabilityTestReportsResponse: AWSDecodableShape {
        /// An object that contains a lists of predictive inbox placement tests that you've performed.
        public let deliverabilityTestReports: [DeliverabilityTestReport]
        /// A token that indicates that there are additional predictive inbox placement tests to list. To view additional predictive inbox placement tests, issue another request to ListDeliverabilityTestReports, and pass this token in the NextToken parameter.
        public let nextToken: String?

        @inlinable
        public init(deliverabilityTestReports: [DeliverabilityTestReport], nextToken: String? = nil) {
            self.deliverabilityTestReports = deliverabilityTestReports
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case deliverabilityTestReports = "DeliverabilityTestReports"
            case nextToken = "NextToken"
        }
    }

    public struct ListDomainDeliverabilityCampaignsRequest: AWSEncodableShape {
        /// The last day that you want to obtain deliverability data for. This value has to be less than or equal to 30 days after the value of the StartDate parameter.
        public let endDate: Date
        /// A token that’s returned from a previous call to the ListDomainDeliverabilityCampaigns operation. This token indicates the position of a campaign in the list of campaigns.
        public let nextToken: String?
        /// The maximum number of results to include in response to a single call to the ListDomainDeliverabilityCampaigns operation. If the number of results is larger than the number that you specify in this parameter, the response includes a NextToken element, which you can use to obtain additional results.
        public let pageSize: Int?
        /// The first day that you want to obtain deliverability data for.
        public let startDate: Date
        /// The domain to obtain deliverability data for.
        public let subscribedDomain: String

        @inlinable
        public init(endDate: Date, nextToken: String? = nil, pageSize: Int? = nil, startDate: Date, subscribedDomain: String) {
            self.endDate = endDate
            self.nextToken = nextToken
            self.pageSize = pageSize
            self.startDate = startDate
            self.subscribedDomain = subscribedDomain
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.endDate, key: "EndDate")
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
            request.encodeQuery(self.startDate, key: "StartDate")
            request.encodePath(self.subscribedDomain, key: "SubscribedDomain")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListDomainDeliverabilityCampaignsResponse: AWSDecodableShape {
        /// An array of responses, one for each campaign that used the domain to send email during the specified time range.
        public let domainDeliverabilityCampaigns: [DomainDeliverabilityCampaign]
        /// A token that’s returned from a previous call to the ListDomainDeliverabilityCampaigns operation. This token indicates the position of the campaign in the list of campaigns.
        public let nextToken: String?

        @inlinable
        public init(domainDeliverabilityCampaigns: [DomainDeliverabilityCampaign], nextToken: String? = nil) {
            self.domainDeliverabilityCampaigns = domainDeliverabilityCampaigns
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case domainDeliverabilityCampaigns = "DomainDeliverabilityCampaigns"
            case nextToken = "NextToken"
        }
    }

    public struct ListEmailIdentitiesRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListEmailIdentities to indicate the position in the list of identities.
        public let nextToken: String?
        /// The number of results to show in a single call to ListEmailIdentities. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results. The value you specify has to be at least 0, and can be no more than 1000.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListEmailIdentitiesResponse: AWSDecodableShape {
        /// An array that includes all of the email identities associated with your Amazon Web Services account.
        public let emailIdentities: [IdentityInfo]?
        /// A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to ListEmailIdentities, and pass this token in the NextToken parameter.
        public let nextToken: String?

        @inlinable
        public init(emailIdentities: [IdentityInfo]? = nil, nextToken: String? = nil) {
            self.emailIdentities = emailIdentities
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case emailIdentities = "EmailIdentities"
            case nextToken = "NextToken"
        }
    }

    public struct ListEmailTemplatesRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListEmailTemplates to indicate the position in the list of email templates.
        public let nextToken: String?
        /// The number of results to show in a single call to ListEmailTemplates. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results. The value you specify has to be at least 1, and can be no more than 100.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListEmailTemplatesResponse: AWSDecodableShape {
        /// A token indicating that there are additional email templates available to be listed. Pass this token to a subsequent ListEmailTemplates call to retrieve the next 10 email templates.
        public let nextToken: String?
        /// An array the contains the name and creation time stamp for each template in your Amazon SES account.
        public let templatesMetadata: [EmailTemplateMetadata]?

        @inlinable
        public init(nextToken: String? = nil, templatesMetadata: [EmailTemplateMetadata]? = nil) {
            self.nextToken = nextToken
            self.templatesMetadata = templatesMetadata
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case templatesMetadata = "TemplatesMetadata"
        }
    }

    public struct ListExportJobsRequest: AWSEncodableShape {
        /// A value used to list export jobs that have a certain ExportSourceType.
        public let exportSourceType: ExportSourceType?
        /// A value used to list export jobs that have a certain JobStatus.
        public let jobStatus: JobStatus?
        /// The pagination token returned from a previous call to ListExportJobs to indicate the position in the list of export jobs.
        public let nextToken: String?
        /// Maximum number of export jobs to return at once. Use this parameter to paginate results. If additional export jobs exist beyond the specified limit, the NextToken element is sent in the response. Use the NextToken value in subsequent calls to ListExportJobs to retrieve additional export jobs.
        public let pageSize: Int?

        @inlinable
        public init(exportSourceType: ExportSourceType? = nil, jobStatus: JobStatus? = nil, nextToken: String? = nil, pageSize: Int? = nil) {
            self.exportSourceType = exportSourceType
            self.jobStatus = jobStatus
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        private enum CodingKeys: String, CodingKey {
            case exportSourceType = "ExportSourceType"
            case jobStatus = "JobStatus"
            case nextToken = "NextToken"
            case pageSize = "PageSize"
        }
    }

    public struct ListExportJobsResponse: AWSDecodableShape {
        /// A list of the export job summaries.
        public let exportJobs: [ExportJobSummary]?
        /// A string token indicating that there might be additional export jobs available to be listed. Use this token to a subsequent call to ListExportJobs with the same parameters to retrieve the next page of export jobs.
        public let nextToken: String?

        @inlinable
        public init(exportJobs: [ExportJobSummary]? = nil, nextToken: String? = nil) {
            self.exportJobs = exportJobs
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case exportJobs = "ExportJobs"
            case nextToken = "NextToken"
        }
    }

    public struct ListImportJobsRequest: AWSEncodableShape {
        /// The destination of the import job, which can be used to list import jobs that have a certain ImportDestinationType.
        public let importDestinationType: ImportDestinationType?
        /// A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to ListImportJobs with the same parameters to retrieve the next page of import jobs.
        public let nextToken: String?
        /// Maximum number of import jobs to return at once. Use this parameter to paginate results. If additional import jobs exist beyond the specified limit, the NextToken element is sent in the response. Use the NextToken value in subsequent requests to retrieve additional addresses.
        public let pageSize: Int?

        @inlinable
        public init(importDestinationType: ImportDestinationType? = nil, nextToken: String? = nil, pageSize: Int? = nil) {
            self.importDestinationType = importDestinationType
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        private enum CodingKeys: String, CodingKey {
            case importDestinationType = "ImportDestinationType"
            case nextToken = "NextToken"
            case pageSize = "PageSize"
        }
    }

    public struct ListImportJobsResponse: AWSDecodableShape {
        /// A list of the import job summaries.
        public let importJobs: [ImportJobSummary]?
        /// A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to ListImportJobs with the same parameters to retrieve the next page of import jobs.
        public let nextToken: String?

        @inlinable
        public init(importJobs: [ImportJobSummary]? = nil, nextToken: String? = nil) {
            self.importJobs = importJobs
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case importJobs = "ImportJobs"
            case nextToken = "NextToken"
        }
    }

    public struct ListManagementOptions: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String
        /// The name of the topic.
        public let topicName: String?

        @inlinable
        public init(contactListName: String, topicName: String? = nil) {
            self.contactListName = contactListName
            self.topicName = topicName
        }

        private enum CodingKeys: String, CodingKey {
            case contactListName = "ContactListName"
            case topicName = "TopicName"
        }
    }

    public struct ListMultiRegionEndpointsRequest: AWSEncodableShape {
        /// A token returned from a previous call to ListMultiRegionEndpoints to indicate the position in the list of multi-region endpoints (global-endpoints).
        public let nextToken: String?
        /// The number of results to show in a single call to ListMultiRegionEndpoints. If the number of results is larger than the number you specified in this parameter, the response includes a NextToken element that you can use to retrieve the next page of results.
        public let pageSize: Int?

        @inlinable
        public init(nextToken: String? = nil, pageSize: Int? = nil) {
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
        }

        public func validate(name: String) throws {
            try self.validate(self.nextToken, name: "nextToken", parent: name, max: 5000)
            try self.validate(self.nextToken, name: "nextToken", parent: name, min: 1)
            try self.validate(self.nextToken, name: "nextToken", parent: name, pattern: "^^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$")
            try self.validate(self.pageSize, name: "pageSize", parent: name, max: 1000)
            try self.validate(self.pageSize, name: "pageSize", parent: name, min: 1)
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListMultiRegionEndpointsResponse: AWSDecodableShape {
        /// An array that contains key multi-region endpoint (global-endpoint) properties.
        public let multiRegionEndpoints: [MultiRegionEndpoint]?
        /// A token indicating that there are additional multi-region endpoints (global-endpoints) available to be listed. Pass this token to a subsequent ListMultiRegionEndpoints call to retrieve the next page.
        public let nextToken: String?

        @inlinable
        public init(multiRegionEndpoints: [MultiRegionEndpoint]? = nil, nextToken: String? = nil) {
            self.multiRegionEndpoints = multiRegionEndpoints
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case multiRegionEndpoints = "MultiRegionEndpoints"
            case nextToken = "NextToken"
        }
    }

    public struct ListRecommendationsRequest: AWSEncodableShape {
        /// Filters applied when retrieving recommendations. Can eiter be an individual filter, or combinations of STATUS and IMPACT or STATUS and TYPE
        public let filter: [ListRecommendationsFilterKey: String]?
        /// A token returned from a previous call to ListRecommendations to indicate the position in the list of recommendations.
        public let nextToken: String?
        /// The number of results to show in a single call to ListRecommendations. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results. The value you specify has to be at least 1, and can be no more than 100.
        public let pageSize: Int?

        @inlinable
        public init(filter: [ListRecommendationsFilterKey: String]? = nil, nextToken: String? = nil, pageSize: Int? = nil) {
            self.filter = filter
            self.nextToken = nextToken
            self.pageSize = pageSize
        }

        public func validate(name: String) throws {
            try self.filter?.forEach {
                try validate($0.value, name: "filter[\"\($0.key)\"]", parent: name, max: 512)
                try validate($0.value, name: "filter[\"\($0.key)\"]", parent: name, min: 1)
            }
            try self.validate(self.filter, name: "filter", parent: name, max: 2)
            try self.validate(self.filter, name: "filter", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case filter = "Filter"
            case nextToken = "NextToken"
            case pageSize = "PageSize"
        }
    }

    public struct ListRecommendationsResponse: AWSDecodableShape {
        /// A string token indicating that there might be additional recommendations available to be listed. Use the token provided in the ListRecommendationsResponse to use in the subsequent call to ListRecommendations with the same parameters to retrieve the next page of recommendations.
        public let nextToken: String?
        /// The recommendations applicable to your account.
        public let recommendations: [Recommendation]?

        @inlinable
        public init(nextToken: String? = nil, recommendations: [Recommendation]? = nil) {
            self.nextToken = nextToken
            self.recommendations = recommendations
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case recommendations = "Recommendations"
        }
    }

    public struct ListSuppressedDestinationsRequest: AWSEncodableShape {
        /// Used to filter the list of suppressed email destinations so that it only includes addresses that were added to the list before a specific date.
        public let endDate: Date?
        /// A token returned from a previous call to ListSuppressedDestinations to indicate the position in the list of suppressed email addresses.
        public let nextToken: String?
        /// The number of results to show in a single call to ListSuppressedDestinations. If the number of results is larger than the number you specified in this parameter, then the response includes a NextToken element, which you can use to obtain additional results.
        public let pageSize: Int?
        /// The factors that caused the email address to be added to .
        public let reasons: [SuppressionListReason]?
        /// Used to filter the list of suppressed email destinations so that it only includes addresses that were added to the list after a specific date.
        public let startDate: Date?

        @inlinable
        public init(endDate: Date? = nil, nextToken: String? = nil, pageSize: Int? = nil, reasons: [SuppressionListReason]? = nil, startDate: Date? = nil) {
            self.endDate = endDate
            self.nextToken = nextToken
            self.pageSize = pageSize
            self.reasons = reasons
            self.startDate = startDate
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.endDate, key: "EndDate")
            request.encodeQuery(self.nextToken, key: "NextToken")
            request.encodeQuery(self.pageSize, key: "PageSize")
            request.encodeQuery(self.reasons, key: "Reason")
            request.encodeQuery(self.startDate, key: "StartDate")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListSuppressedDestinationsResponse: AWSDecodableShape {
        /// A token that indicates that there are additional email addresses on the suppression list for your account. To view additional suppressed addresses, issue another request to ListSuppressedDestinations, and pass this token in the NextToken parameter.
        public let nextToken: String?
        /// A list of summaries, each containing a summary for a suppressed email destination.
        public let suppressedDestinationSummaries: [SuppressedDestinationSummary]?

        @inlinable
        public init(nextToken: String? = nil, suppressedDestinationSummaries: [SuppressedDestinationSummary]? = nil) {
            self.nextToken = nextToken
            self.suppressedDestinationSummaries = suppressedDestinationSummaries
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case suppressedDestinationSummaries = "SuppressedDestinationSummaries"
        }
    }

    public struct ListTagsForResourceRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the resource that you want to retrieve tag information for.
        public let resourceArn: String

        @inlinable
        public init(resourceArn: String) {
            self.resourceArn = resourceArn
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.resourceArn, key: "ResourceArn")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct ListTagsForResourceResponse: AWSDecodableShape {
        /// An array that lists all the tags that are associated with the resource. Each tag consists of a required tag key (Key) and an associated tag value (Value)
        public let tags: [Tag]

        @inlinable
        public init(tags: [Tag]) {
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case tags = "Tags"
        }
    }

    public struct MailFromAttributes: AWSDecodableShape {
        /// The action to take if the required MX record can't be found when you send an email. When you set this value to USE_DEFAULT_VALUE, the mail is sent using amazonses.com as the MAIL FROM domain. When you set this value to REJECT_MESSAGE, the Amazon SES API v2 returns a MailFromDomainNotVerified error, and doesn't attempt to deliver the email. These behaviors are taken when the custom MAIL FROM domain configuration is in the Pending, Failed, and TemporaryFailure states.
        public let behaviorOnMxFailure: BehaviorOnMxFailure
        /// The name of a domain that an email identity uses as a custom MAIL FROM domain.
        public let mailFromDomain: String
        /// The status of the MAIL FROM domain. This status can have the following values:    PENDING – Amazon SES hasn't started searching for the MX record yet.    SUCCESS – Amazon SES detected the required MX record for the MAIL FROM domain.    FAILED – Amazon SES can't find the required MX record, or the record no longer exists.    TEMPORARY_FAILURE – A temporary issue occurred, which prevented Amazon SES from determining the status of the MAIL FROM domain.
        public let mailFromDomainStatus: MailFromDomainStatus

        @inlinable
        public init(behaviorOnMxFailure: BehaviorOnMxFailure, mailFromDomain: String, mailFromDomainStatus: MailFromDomainStatus) {
            self.behaviorOnMxFailure = behaviorOnMxFailure
            self.mailFromDomain = mailFromDomain
            self.mailFromDomainStatus = mailFromDomainStatus
        }

        private enum CodingKeys: String, CodingKey {
            case behaviorOnMxFailure = "BehaviorOnMxFailure"
            case mailFromDomain = "MailFromDomain"
            case mailFromDomainStatus = "MailFromDomainStatus"
        }
    }

    public struct Message: AWSEncodableShape {
        ///  The List of attachments to include in your email. All recipients will receive the same attachments.
        public let attachments: [Attachment]?
        /// The body of the message. You can specify an HTML version of the message, a text-only version of the message, or both.
        public let body: Body
        /// The list of message headers that will be added to the email message.
        public let headers: [MessageHeader]?
        /// The subject line of the email. The subject line can only contain 7-bit ASCII characters. However, you can specify non-ASCII characters in the subject line by using encoded-word syntax, as described in RFC 2047.
        public let subject: Content

        @inlinable
        public init(attachments: [Attachment]? = nil, body: Body, headers: [MessageHeader]? = nil, subject: Content) {
            self.attachments = attachments
            self.body = body
            self.headers = headers
            self.subject = subject
        }

        public func validate(name: String) throws {
            try self.attachments?.forEach {
                try $0.validate(name: "\(name).attachments[]")
            }
            try self.headers?.forEach {
                try $0.validate(name: "\(name).headers[]")
            }
            try self.validate(self.headers, name: "headers", parent: name, max: 15)
        }

        private enum CodingKeys: String, CodingKey {
            case attachments = "Attachments"
            case body = "Body"
            case headers = "Headers"
            case subject = "Subject"
        }
    }

    public struct MessageHeader: AWSEncodableShape {
        /// The name of the message header. The message header name has to meet the following criteria:   Can contain any printable ASCII character (33 - 126) except for colon (:).   Can contain no more than 126 characters.
        public let name: String
        /// The value of the message header. The message header value has to meet the following criteria:   Can contain any printable ASCII character.   Can contain no more than 870 characters.
        public let value: String

        @inlinable
        public init(name: String, value: String) {
            self.name = name
            self.value = value
        }

        public func validate(name: String) throws {
            try self.validate(self.name, name: "name", parent: name, max: 126)
            try self.validate(self.name, name: "name", parent: name, min: 1)
            try self.validate(self.name, name: "name", parent: name, pattern: "^[!-9;-@A-~]+$")
            try self.validate(self.value, name: "value", parent: name, max: 870)
            try self.validate(self.value, name: "value", parent: name, min: 1)
            try self.validate(self.value, name: "value", parent: name, pattern: "^[ -~]*$")
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case value = "Value"
        }
    }

    public struct MessageInsightsDataSource: AWSEncodableShape & AWSDecodableShape {
        /// Represents the end date for the export interval as a timestamp. The end date is inclusive.
        public let endDate: Date
        /// Filters for results to be excluded from the export file.
        public let exclude: MessageInsightsFilters?
        /// Filters for results to be included in the export file.
        public let include: MessageInsightsFilters?
        /// The maximum number of results.
        public let maxResults: Int?
        /// Represents the start date for the export interval as a timestamp. The start date is inclusive.
        public let startDate: Date

        @inlinable
        public init(endDate: Date, exclude: MessageInsightsFilters? = nil, include: MessageInsightsFilters? = nil, maxResults: Int? = nil, startDate: Date) {
            self.endDate = endDate
            self.exclude = exclude
            self.include = include
            self.maxResults = maxResults
            self.startDate = startDate
        }

        public func validate(name: String) throws {
            try self.exclude?.validate(name: "\(name).exclude")
            try self.include?.validate(name: "\(name).include")
            try self.validate(self.maxResults, name: "maxResults", parent: name, max: 10000)
            try self.validate(self.maxResults, name: "maxResults", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case endDate = "EndDate"
            case exclude = "Exclude"
            case include = "Include"
            case maxResults = "MaxResults"
            case startDate = "StartDate"
        }
    }

    public struct MessageInsightsFilters: AWSEncodableShape & AWSDecodableShape {
        /// The recipient's email address.
        public let destination: [String]?
        /// The from address used to send the message.
        public let fromEmailAddress: [String]?
        /// The recipient's ISP (e.g., Gmail, Yahoo, etc.).
        public let isp: [String]?
        ///  The last delivery-related event for the email, where the ordering is as follows: SEND BOUNCE DELIVERY COMPLAINT.
        public let lastDeliveryEvent: [DeliveryEventType]?
        ///  The last engagement-related event for the email, where the ordering is as follows: OPEN CLICK.   Engagement events are only available if Engagement tracking is enabled.
        public let lastEngagementEvent: [EngagementEventType]?
        /// The subject line of the message.
        public let subject: [String]?

        @inlinable
        public init(destination: [String]? = nil, fromEmailAddress: [String]? = nil, isp: [String]? = nil, lastDeliveryEvent: [DeliveryEventType]? = nil, lastEngagementEvent: [EngagementEventType]? = nil, subject: [String]? = nil) {
            self.destination = destination
            self.fromEmailAddress = fromEmailAddress
            self.isp = isp
            self.lastDeliveryEvent = lastDeliveryEvent
            self.lastEngagementEvent = lastEngagementEvent
            self.subject = subject
        }

        public func validate(name: String) throws {
            try self.destination?.forEach {
                try validate($0, name: "destination[]", parent: name, max: 320)
                try validate($0, name: "destination[]", parent: name, min: 1)
            }
            try self.validate(self.destination, name: "destination", parent: name, max: 5)
            try self.fromEmailAddress?.forEach {
                try validate($0, name: "fromEmailAddress[]", parent: name, max: 320)
                try validate($0, name: "fromEmailAddress[]", parent: name, min: 1)
            }
            try self.validate(self.fromEmailAddress, name: "fromEmailAddress", parent: name, max: 5)
            try self.validate(self.isp, name: "isp", parent: name, max: 5)
            try self.validate(self.lastDeliveryEvent, name: "lastDeliveryEvent", parent: name, max: 5)
            try self.validate(self.lastEngagementEvent, name: "lastEngagementEvent", parent: name, max: 2)
            try self.subject?.forEach {
                try validate($0, name: "subject[]", parent: name, max: 998)
                try validate($0, name: "subject[]", parent: name, min: 1)
            }
            try self.validate(self.subject, name: "subject", parent: name, max: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case destination = "Destination"
            case fromEmailAddress = "FromEmailAddress"
            case isp = "Isp"
            case lastDeliveryEvent = "LastDeliveryEvent"
            case lastEngagementEvent = "LastEngagementEvent"
            case subject = "Subject"
        }
    }

    public struct MessageTag: AWSEncodableShape & AWSDecodableShape {
        /// The name of the message tag. The message tag name has to meet the following criteria:   It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-).   It can contain no more than 256 characters.
        public let name: String
        /// The value of the message tag. The message tag value has to meet the following criteria:   It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-).   It can contain no more than 256 characters.
        public let value: String

        @inlinable
        public init(name: String, value: String) {
            self.name = name
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case name = "Name"
            case value = "Value"
        }
    }

    public struct MetricDataError: AWSDecodableShape {
        /// The query error code. Can be one of:    INTERNAL_FAILURE – Amazon SES has failed to process one of the queries.    ACCESS_DENIED – You have insufficient access to retrieve metrics based on the given query.
        public let code: QueryErrorCode?
        /// The query identifier.
        public let id: String?
        /// The error message associated with the current query error.
        public let message: String?

        @inlinable
        public init(code: QueryErrorCode? = nil, id: String? = nil, message: String? = nil) {
            self.code = code
            self.id = id
            self.message = message
        }

        private enum CodingKeys: String, CodingKey {
            case code = "Code"
            case id = "Id"
            case message = "Message"
        }
    }

    public struct MetricDataResult: AWSDecodableShape {
        /// The query identifier.
        public let id: String?
        /// A list of timestamps for the metric data results.
        public let timestamps: [Date]?
        /// A list of values (cumulative / sum) for the metric data results.
        public let values: [Int64]?

        @inlinable
        public init(id: String? = nil, timestamps: [Date]? = nil, values: [Int64]? = nil) {
            self.id = id
            self.timestamps = timestamps
            self.values = values
        }

        private enum CodingKeys: String, CodingKey {
            case id = "Id"
            case timestamps = "Timestamps"
            case values = "Values"
        }
    }

    public struct MetricsDataSource: AWSEncodableShape & AWSDecodableShape {
        /// An object that contains a mapping between a MetricDimensionName and MetricDimensionValue to filter metrics by. Must contain a least 1 dimension but no more than 3 unique ones.
        public let dimensions: [MetricDimensionName: [String]]
        /// Represents the end date for the export interval as a timestamp.
        public let endDate: Date
        /// A list of ExportMetric objects to export.
        public let metrics: [ExportMetric]
        /// The metrics namespace - e.g., VDM.
        public let namespace: MetricNamespace
        /// Represents the start date for the export interval as a timestamp.
        public let startDate: Date

        @inlinable
        public init(dimensions: [MetricDimensionName: [String]], endDate: Date, metrics: [ExportMetric], namespace: MetricNamespace, startDate: Date) {
            self.dimensions = dimensions
            self.endDate = endDate
            self.metrics = metrics
            self.namespace = namespace
            self.startDate = startDate
        }

        public func validate(name: String) throws {
            try self.dimensions.forEach {
                try validate($0.value, name: "dimensions[\"\($0.key)\"]", parent: name, max: 10)
                try validate($0.value, name: "dimensions[\"\($0.key)\"]", parent: name, min: 1)
            }
            try self.validate(self.dimensions, name: "dimensions", parent: name, max: 3)
            try self.validate(self.dimensions, name: "dimensions", parent: name, min: 1)
            try self.validate(self.metrics, name: "metrics", parent: name, max: 10)
            try self.validate(self.metrics, name: "metrics", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case dimensions = "Dimensions"
            case endDate = "EndDate"
            case metrics = "Metrics"
            case namespace = "Namespace"
            case startDate = "StartDate"
        }
    }

    public struct MultiRegionEndpoint: AWSDecodableShape {
        /// The time stamp of when the multi-region endpoint (global-endpoint) was created.
        public let createdTimestamp: Date?
        /// The ID of the multi-region endpoint (global-endpoint).
        public let endpointId: String?
        /// The name of the multi-region endpoint (global-endpoint).
        public let endpointName: String?
        /// The time stamp of when the multi-region endpoint (global-endpoint) was last updated.
        public let lastUpdatedTimestamp: Date?
        /// Primary and secondary regions between which multi-region endpoint splits sending traffic.
        public let regions: [String]?
        /// The status of the multi-region endpoint (global-endpoint).    CREATING – The resource is being provisioned.    READY – The resource is ready to use.    FAILED – The resource failed to be provisioned.    DELETING – The resource is being deleted as requested.
        public let status: Status?

        @inlinable
        public init(createdTimestamp: Date? = nil, endpointId: String? = nil, endpointName: String? = nil, lastUpdatedTimestamp: Date? = nil, regions: [String]? = nil, status: Status? = nil) {
            self.createdTimestamp = createdTimestamp
            self.endpointId = endpointId
            self.endpointName = endpointName
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.regions = regions
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case createdTimestamp = "CreatedTimestamp"
            case endpointId = "EndpointId"
            case endpointName = "EndpointName"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case regions = "Regions"
            case status = "Status"
        }
    }

    public struct OverallVolume: AWSDecodableShape {
        /// An object that contains inbox and junk mail placement metrics for individual email providers.
        public let domainIspPlacements: [DomainIspPlacement]?
        /// The percentage of emails that were sent from the domain that were read by their recipients.
        public let readRatePercent: Double?
        /// An object that contains information about the numbers of messages that arrived in recipients' inboxes and junk mail folders.
        public let volumeStatistics: VolumeStatistics?

        @inlinable
        public init(domainIspPlacements: [DomainIspPlacement]? = nil, readRatePercent: Double? = nil, volumeStatistics: VolumeStatistics? = nil) {
            self.domainIspPlacements = domainIspPlacements
            self.readRatePercent = readRatePercent
            self.volumeStatistics = volumeStatistics
        }

        private enum CodingKeys: String, CodingKey {
            case domainIspPlacements = "DomainIspPlacements"
            case readRatePercent = "ReadRatePercent"
            case volumeStatistics = "VolumeStatistics"
        }
    }

    public struct PinpointDestination: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Amazon Pinpoint project to send email events to.
        public let applicationArn: String?

        @inlinable
        public init(applicationArn: String? = nil) {
            self.applicationArn = applicationArn
        }

        private enum CodingKeys: String, CodingKey {
            case applicationArn = "ApplicationArn"
        }
    }

    public struct PlacementStatistics: AWSDecodableShape {
        /// The percentage of emails that were authenticated by using DomainKeys Identified Mail (DKIM) during the predictive inbox placement test.
        public let dkimPercentage: Double?
        /// The percentage of emails that arrived in recipients' inboxes during the predictive inbox placement test.
        public let inboxPercentage: Double?
        /// The percentage of emails that didn't arrive in recipients' inboxes at all during the predictive inbox placement test.
        public let missingPercentage: Double?
        /// The percentage of emails that arrived in recipients' spam or junk mail folders during the predictive inbox placement test.
        public let spamPercentage: Double?
        /// The percentage of emails that were authenticated by using Sender Policy Framework (SPF) during the predictive inbox placement test.
        public let spfPercentage: Double?

        @inlinable
        public init(dkimPercentage: Double? = nil, inboxPercentage: Double? = nil, missingPercentage: Double? = nil, spamPercentage: Double? = nil, spfPercentage: Double? = nil) {
            self.dkimPercentage = dkimPercentage
            self.inboxPercentage = inboxPercentage
            self.missingPercentage = missingPercentage
            self.spamPercentage = spamPercentage
            self.spfPercentage = spfPercentage
        }

        private enum CodingKeys: String, CodingKey {
            case dkimPercentage = "DkimPercentage"
            case inboxPercentage = "InboxPercentage"
            case missingPercentage = "MissingPercentage"
            case spamPercentage = "SpamPercentage"
            case spfPercentage = "SpfPercentage"
        }
    }

    public struct PutAccountDedicatedIpWarmupAttributesRequest: AWSEncodableShape {
        /// Enables or disables the automatic warm-up feature for dedicated IP addresses that are associated with your Amazon SES account in the current Amazon Web Services Region. Set to true to enable the automatic warm-up feature, or set to false to disable it.
        public let autoWarmupEnabled: Bool?

        @inlinable
        public init(autoWarmupEnabled: Bool? = nil) {
            self.autoWarmupEnabled = autoWarmupEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case autoWarmupEnabled = "AutoWarmupEnabled"
        }
    }

    public struct PutAccountDedicatedIpWarmupAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutAccountDetailsRequest: AWSEncodableShape {
        /// Additional email addresses that you would like to be notified regarding Amazon SES matters.
        public let additionalContactEmailAddresses: [String]?
        /// The language you would prefer to be contacted with.
        public let contactLanguage: ContactLanguage?
        /// The type of email your account will send.
        public let mailType: MailType
        /// Indicates whether or not your account should have production access in the current Amazon Web Services Region. If the value is false, then your account is in the sandbox. When your account is in the sandbox, you can only send email to verified identities.  If the value is true, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.
        public let productionAccessEnabled: Bool?
        /// A description of the types of email that you plan to send.
        public let useCaseDescription: String?
        /// The URL of your website. This information helps us better understand the type of content that you plan to send.
        public let websiteURL: String

        @inlinable
        public init(additionalContactEmailAddresses: [String]? = nil, contactLanguage: ContactLanguage? = nil, mailType: MailType, productionAccessEnabled: Bool? = nil, useCaseDescription: String? = nil, websiteURL: String) {
            self.additionalContactEmailAddresses = additionalContactEmailAddresses
            self.contactLanguage = contactLanguage
            self.mailType = mailType
            self.productionAccessEnabled = productionAccessEnabled
            self.useCaseDescription = useCaseDescription
            self.websiteURL = websiteURL
        }

        public func validate(name: String) throws {
            try self.additionalContactEmailAddresses?.forEach {
                try validate($0, name: "additionalContactEmailAddresses[]", parent: name, max: 254)
                try validate($0, name: "additionalContactEmailAddresses[]", parent: name, min: 6)
                try validate($0, name: "additionalContactEmailAddresses[]", parent: name, pattern: "^(.+)@(.+)$")
            }
            try self.validate(self.additionalContactEmailAddresses, name: "additionalContactEmailAddresses", parent: name, max: 4)
            try self.validate(self.additionalContactEmailAddresses, name: "additionalContactEmailAddresses", parent: name, min: 1)
            try self.validate(self.useCaseDescription, name: "useCaseDescription", parent: name, max: 5000)
            try self.validate(self.websiteURL, name: "websiteURL", parent: name, max: 1000)
            try self.validate(self.websiteURL, name: "websiteURL", parent: name, min: 1)
            try self.validate(self.websiteURL, name: "websiteURL", parent: name, pattern: "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$")
        }

        private enum CodingKeys: String, CodingKey {
            case additionalContactEmailAddresses = "AdditionalContactEmailAddresses"
            case contactLanguage = "ContactLanguage"
            case mailType = "MailType"
            case productionAccessEnabled = "ProductionAccessEnabled"
            case useCaseDescription = "UseCaseDescription"
            case websiteURL = "WebsiteURL"
        }
    }

    public struct PutAccountDetailsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutAccountSendingAttributesRequest: AWSEncodableShape {
        /// Enables or disables your account's ability to send email. Set to true to enable email sending, or set to false to disable email sending.  If Amazon Web Services paused your account's ability to send email, you can't use this operation to resume your account's ability to send email.
        public let sendingEnabled: Bool?

        @inlinable
        public init(sendingEnabled: Bool? = nil) {
            self.sendingEnabled = sendingEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case sendingEnabled = "SendingEnabled"
        }
    }

    public struct PutAccountSendingAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutAccountSuppressionAttributesRequest: AWSEncodableShape {
        /// A list that contains the reasons that email addresses will be automatically added to the suppression list for your account. This list can contain any or all of the following:    COMPLAINT – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a complaint.    BOUNCE – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a hard bounce.
        public let suppressedReasons: [SuppressionListReason]?

        @inlinable
        public init(suppressedReasons: [SuppressionListReason]? = nil) {
            self.suppressedReasons = suppressedReasons
        }

        private enum CodingKeys: String, CodingKey {
            case suppressedReasons = "SuppressedReasons"
        }
    }

    public struct PutAccountSuppressionAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutAccountVdmAttributesRequest: AWSEncodableShape {
        /// The VDM attributes that you wish to apply to your Amazon SES account.
        public let vdmAttributes: VdmAttributes

        @inlinable
        public init(vdmAttributes: VdmAttributes) {
            self.vdmAttributes = vdmAttributes
        }

        private enum CodingKeys: String, CodingKey {
            case vdmAttributes = "VdmAttributes"
        }
    }

    public struct PutAccountVdmAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetArchivingOptionsRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the MailManager archive that the Amazon SES API v2 sends email to.
        public let archiveArn: String?
        /// The name of the configuration set to associate with a MailManager archive.
        public let configurationSetName: String

        @inlinable
        public init(archiveArn: String? = nil, configurationSetName: String) {
            self.archiveArn = archiveArn
            self.configurationSetName = configurationSetName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.archiveArn, forKey: .archiveArn)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
        }

        public func validate(name: String) throws {
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, max: 1011)
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, min: 20)
            try self.validate(self.archiveArn, name: "archiveArn", parent: name, pattern: "^arn:(aws|aws-[a-z-]+):ses:[a-z]{2}-[a-z-]+-[0-9]:[0-9]{1,20}:mailmanager-archive/a-[a-z0-9]{24,62}$")
        }

        private enum CodingKeys: String, CodingKey {
            case archiveArn = "ArchiveArn"
        }
    }

    public struct PutConfigurationSetArchivingOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetDeliveryOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set to associate with a dedicated IP pool.
        public let configurationSetName: String
        /// The maximum amount of time, in seconds, that Amazon SES API v2 will attempt delivery of email. If specified, the value must greater than or equal to 300 seconds (5 minutes) and less than or equal to 50400 seconds (840 minutes).
        public let maxDeliverySeconds: Int64?
        /// The name of the dedicated IP pool to associate with the configuration set.
        public let sendingPoolName: String?
        /// Specifies whether messages that use the configuration set are required to use Transport Layer Security (TLS). If the value is Require, messages are only delivered if a TLS connection can be established. If the value is Optional, messages can be delivered in plain text if a TLS connection can't be established.
        public let tlsPolicy: TlsPolicy?

        @inlinable
        public init(configurationSetName: String, maxDeliverySeconds: Int64? = nil, sendingPoolName: String? = nil, tlsPolicy: TlsPolicy? = nil) {
            self.configurationSetName = configurationSetName
            self.maxDeliverySeconds = maxDeliverySeconds
            self.sendingPoolName = sendingPoolName
            self.tlsPolicy = tlsPolicy
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.maxDeliverySeconds, forKey: .maxDeliverySeconds)
            try container.encodeIfPresent(self.sendingPoolName, forKey: .sendingPoolName)
            try container.encodeIfPresent(self.tlsPolicy, forKey: .tlsPolicy)
        }

        public func validate(name: String) throws {
            try self.validate(self.maxDeliverySeconds, name: "maxDeliverySeconds", parent: name, max: 50400)
            try self.validate(self.maxDeliverySeconds, name: "maxDeliverySeconds", parent: name, min: 300)
        }

        private enum CodingKeys: String, CodingKey {
            case maxDeliverySeconds = "MaxDeliverySeconds"
            case sendingPoolName = "SendingPoolName"
            case tlsPolicy = "TlsPolicy"
        }
    }

    public struct PutConfigurationSetDeliveryOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetReputationOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set.
        public let configurationSetName: String
        /// If true, tracking of reputation metrics is enabled for the configuration set. If false, tracking of reputation metrics is disabled for the configuration set.
        public let reputationMetricsEnabled: Bool?

        @inlinable
        public init(configurationSetName: String, reputationMetricsEnabled: Bool? = nil) {
            self.configurationSetName = configurationSetName
            self.reputationMetricsEnabled = reputationMetricsEnabled
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.reputationMetricsEnabled, forKey: .reputationMetricsEnabled)
        }

        private enum CodingKeys: String, CodingKey {
            case reputationMetricsEnabled = "ReputationMetricsEnabled"
        }
    }

    public struct PutConfigurationSetReputationOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetSendingOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set to enable or disable email sending for.
        public let configurationSetName: String
        /// If true, email sending is enabled for the configuration set. If false, email sending is disabled for the configuration set.
        public let sendingEnabled: Bool?

        @inlinable
        public init(configurationSetName: String, sendingEnabled: Bool? = nil) {
            self.configurationSetName = configurationSetName
            self.sendingEnabled = sendingEnabled
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.sendingEnabled, forKey: .sendingEnabled)
        }

        private enum CodingKeys: String, CodingKey {
            case sendingEnabled = "SendingEnabled"
        }
    }

    public struct PutConfigurationSetSendingOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetSuppressionOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set to change the suppression list preferences for.
        public let configurationSetName: String
        /// A list that contains the reasons that email addresses are automatically added to the suppression list for your account. This list can contain any or all of the following:    COMPLAINT – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a complaint.    BOUNCE – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a hard bounce.
        public let suppressedReasons: [SuppressionListReason]?

        @inlinable
        public init(configurationSetName: String, suppressedReasons: [SuppressionListReason]? = nil) {
            self.configurationSetName = configurationSetName
            self.suppressedReasons = suppressedReasons
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.suppressedReasons, forKey: .suppressedReasons)
        }

        private enum CodingKeys: String, CodingKey {
            case suppressedReasons = "SuppressedReasons"
        }
    }

    public struct PutConfigurationSetSuppressionOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetTrackingOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set.
        public let configurationSetName: String
        /// The domain to use to track open and click events.
        public let customRedirectDomain: String?
        public let httpsPolicy: HttpsPolicy?

        @inlinable
        public init(configurationSetName: String, customRedirectDomain: String? = nil, httpsPolicy: HttpsPolicy? = nil) {
            self.configurationSetName = configurationSetName
            self.customRedirectDomain = customRedirectDomain
            self.httpsPolicy = httpsPolicy
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.customRedirectDomain, forKey: .customRedirectDomain)
            try container.encodeIfPresent(self.httpsPolicy, forKey: .httpsPolicy)
        }

        private enum CodingKeys: String, CodingKey {
            case customRedirectDomain = "CustomRedirectDomain"
            case httpsPolicy = "HttpsPolicy"
        }
    }

    public struct PutConfigurationSetTrackingOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutConfigurationSetVdmOptionsRequest: AWSEncodableShape {
        /// The name of the configuration set.
        public let configurationSetName: String
        /// The VDM options to apply to the configuration set.
        public let vdmOptions: VdmOptions?

        @inlinable
        public init(configurationSetName: String, vdmOptions: VdmOptions? = nil) {
            self.configurationSetName = configurationSetName
            self.vdmOptions = vdmOptions
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encodeIfPresent(self.vdmOptions, forKey: .vdmOptions)
        }

        private enum CodingKeys: String, CodingKey {
            case vdmOptions = "VdmOptions"
        }
    }

    public struct PutConfigurationSetVdmOptionsResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutDedicatedIpInPoolRequest: AWSEncodableShape {
        /// The name of the IP pool that you want to add the dedicated IP address to. You have to specify an IP pool that already exists.
        public let destinationPoolName: String
        /// The IP address that you want to move to the dedicated IP pool. The value you specify has to be a dedicated IP address that's associated with your Amazon Web Services account.
        public let ip: String

        @inlinable
        public init(destinationPoolName: String, ip: String) {
            self.destinationPoolName = destinationPoolName
            self.ip = ip
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encode(self.destinationPoolName, forKey: .destinationPoolName)
            request.encodePath(self.ip, key: "Ip")
        }

        private enum CodingKeys: String, CodingKey {
            case destinationPoolName = "DestinationPoolName"
        }
    }

    public struct PutDedicatedIpInPoolResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutDedicatedIpPoolScalingAttributesRequest: AWSEncodableShape {
        /// The name of the dedicated IP pool.
        public let poolName: String
        /// The scaling mode to apply to the dedicated IP pool.  Changing the scaling mode from MANAGED to STANDARD is not supported.
        public let scalingMode: ScalingMode

        @inlinable
        public init(poolName: String, scalingMode: ScalingMode) {
            self.poolName = poolName
            self.scalingMode = scalingMode
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.poolName, key: "PoolName")
            try container.encode(self.scalingMode, forKey: .scalingMode)
        }

        private enum CodingKeys: String, CodingKey {
            case scalingMode = "ScalingMode"
        }
    }

    public struct PutDedicatedIpPoolScalingAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutDedicatedIpWarmupAttributesRequest: AWSEncodableShape {
        /// The dedicated IP address that you want to update the warm-up attributes for.
        public let ip: String
        /// The warm-up percentage that you want to associate with the dedicated IP address.
        public let warmupPercentage: Int

        @inlinable
        public init(ip: String, warmupPercentage: Int) {
            self.ip = ip
            self.warmupPercentage = warmupPercentage
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.ip, key: "Ip")
            try container.encode(self.warmupPercentage, forKey: .warmupPercentage)
        }

        private enum CodingKeys: String, CodingKey {
            case warmupPercentage = "WarmupPercentage"
        }
    }

    public struct PutDedicatedIpWarmupAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutDeliverabilityDashboardOptionRequest: AWSEncodableShape {
        /// Specifies whether to enable the Deliverability dashboard. To enable the dashboard, set this value to true.
        public let dashboardEnabled: Bool
        /// An array of objects, one for each verified domain that you use to send email and enabled the Deliverability dashboard for.
        public let subscribedDomains: [DomainDeliverabilityTrackingOption]?

        @inlinable
        public init(dashboardEnabled: Bool = false, subscribedDomains: [DomainDeliverabilityTrackingOption]? = nil) {
            self.dashboardEnabled = dashboardEnabled
            self.subscribedDomains = subscribedDomains
        }

        private enum CodingKeys: String, CodingKey {
            case dashboardEnabled = "DashboardEnabled"
            case subscribedDomains = "SubscribedDomains"
        }
    }

    public struct PutDeliverabilityDashboardOptionResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutEmailIdentityConfigurationSetAttributesRequest: AWSEncodableShape {
        /// The configuration set to associate with an email identity.
        public let configurationSetName: String?
        /// The email address or domain to associate with a configuration set.
        public let emailIdentity: String

        @inlinable
        public init(configurationSetName: String? = nil, emailIdentity: String) {
            self.configurationSetName = configurationSetName
            self.emailIdentity = emailIdentity
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.configurationSetName, forKey: .configurationSetName)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSetName = "ConfigurationSetName"
        }
    }

    public struct PutEmailIdentityConfigurationSetAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutEmailIdentityDkimAttributesRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String
        /// Sets the DKIM signing configuration for the identity. When you set this value true, then the messages that are sent from the identity are signed using DKIM. If you set this value to false, your messages are sent without DKIM signing.
        public let signingEnabled: Bool?

        @inlinable
        public init(emailIdentity: String, signingEnabled: Bool? = nil) {
            self.emailIdentity = emailIdentity
            self.signingEnabled = signingEnabled
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            try container.encodeIfPresent(self.signingEnabled, forKey: .signingEnabled)
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case signingEnabled = "SigningEnabled"
        }
    }

    public struct PutEmailIdentityDkimAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutEmailIdentityDkimSigningAttributesRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String
        /// An object that contains information about the private key and selector that you want to use to configure DKIM for the identity for Bring Your Own DKIM (BYODKIM) for the identity, or, configures the key length to be used for Easy DKIM.
        public let signingAttributes: DkimSigningAttributes?
        /// The method to use to configure DKIM for the identity. There are the following possible values:    AWS_SES – Configure DKIM for the identity by using Easy DKIM.    EXTERNAL – Configure DKIM for the identity by using Bring Your Own DKIM (BYODKIM).
        public let signingAttributesOrigin: DkimSigningAttributesOrigin

        @inlinable
        public init(emailIdentity: String, signingAttributes: DkimSigningAttributes? = nil, signingAttributesOrigin: DkimSigningAttributesOrigin) {
            self.emailIdentity = emailIdentity
            self.signingAttributes = signingAttributes
            self.signingAttributesOrigin = signingAttributesOrigin
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            try container.encodeIfPresent(self.signingAttributes, forKey: .signingAttributes)
            try container.encode(self.signingAttributesOrigin, forKey: .signingAttributesOrigin)
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
            try self.signingAttributes?.validate(name: "\(name).signingAttributes")
        }

        private enum CodingKeys: String, CodingKey {
            case signingAttributes = "SigningAttributes"
            case signingAttributesOrigin = "SigningAttributesOrigin"
        }
    }

    public struct PutEmailIdentityDkimSigningAttributesResponse: AWSDecodableShape {
        /// The DKIM authentication status of the identity. Amazon SES determines the authentication status by searching for specific records in the DNS configuration for your domain. If you used Easy DKIM to set up DKIM authentication, Amazon SES tries to find three unique CNAME records in the DNS configuration for your domain. If you provided a public key to perform DKIM authentication, Amazon SES tries to find a TXT record that uses the selector that you specified. The value of the TXT record must be a public key that's paired with the private key that you specified in the process of creating the identity. The status can be one of the following:    PENDING – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.    SUCCESS – The verification process completed successfully.    FAILED – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.    TEMPORARY_FAILURE – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.    NOT_STARTED – The DKIM verification process hasn't been initiated for the domain.
        public let dkimStatus: DkimStatus?
        /// If you used Easy DKIM to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete. If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector that's associated with your public key. Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.
        public let dkimTokens: [String]?

        @inlinable
        public init(dkimStatus: DkimStatus? = nil, dkimTokens: [String]? = nil) {
            self.dkimStatus = dkimStatus
            self.dkimTokens = dkimTokens
        }

        private enum CodingKeys: String, CodingKey {
            case dkimStatus = "DkimStatus"
            case dkimTokens = "DkimTokens"
        }
    }

    public struct PutEmailIdentityFeedbackAttributesRequest: AWSEncodableShape {
        /// Sets the feedback forwarding configuration for the identity. If the value is true, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the Return-Path header of the original email. You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).
        public let emailForwardingEnabled: Bool?
        /// The email identity.
        public let emailIdentity: String

        @inlinable
        public init(emailForwardingEnabled: Bool? = nil, emailIdentity: String) {
            self.emailForwardingEnabled = emailForwardingEnabled
            self.emailIdentity = emailIdentity
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.emailForwardingEnabled, forKey: .emailForwardingEnabled)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case emailForwardingEnabled = "EmailForwardingEnabled"
        }
    }

    public struct PutEmailIdentityFeedbackAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutEmailIdentityMailFromAttributesRequest: AWSEncodableShape {
        /// The action to take if the required MX record isn't found when you send an email. When you set this value to UseDefaultValue, the mail is sent using amazonses.com as the MAIL FROM domain. When you set this value to RejectMessage, the Amazon SES API v2 returns a MailFromDomainNotVerified error, and doesn't attempt to deliver the email. These behaviors are taken when the custom MAIL FROM domain configuration is in the Pending, Failed, and TemporaryFailure states.
        public let behaviorOnMxFailure: BehaviorOnMxFailure?
        /// The verified email identity.
        public let emailIdentity: String
        ///  The custom MAIL FROM domain that you want the verified identity to use. The MAIL FROM domain must meet the following criteria:   It has to be a subdomain of the verified identity.   It can't be used to receive email.   It can't be used in a "From" address if the MAIL FROM domain is a destination for feedback forwarding emails.
        public let mailFromDomain: String?

        @inlinable
        public init(behaviorOnMxFailure: BehaviorOnMxFailure? = nil, emailIdentity: String, mailFromDomain: String? = nil) {
            self.behaviorOnMxFailure = behaviorOnMxFailure
            self.emailIdentity = emailIdentity
            self.mailFromDomain = mailFromDomain
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.behaviorOnMxFailure, forKey: .behaviorOnMxFailure)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            try container.encodeIfPresent(self.mailFromDomain, forKey: .mailFromDomain)
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case behaviorOnMxFailure = "BehaviorOnMxFailure"
            case mailFromDomain = "MailFromDomain"
        }
    }

    public struct PutEmailIdentityMailFromAttributesResponse: AWSDecodableShape {
        public init() {}
    }

    public struct PutSuppressedDestinationRequest: AWSEncodableShape {
        /// The email address that should be added to the suppression list for your account.
        public let emailAddress: String
        /// The factors that should cause the email address to be added to the suppression list for your account.
        public let reason: SuppressionListReason

        @inlinable
        public init(emailAddress: String, reason: SuppressionListReason) {
            self.emailAddress = emailAddress
            self.reason = reason
        }

        private enum CodingKeys: String, CodingKey {
            case emailAddress = "EmailAddress"
            case reason = "Reason"
        }
    }

    public struct PutSuppressedDestinationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct RawMessage: AWSEncodableShape {
        /// The raw email message. The message has to meet the following criteria:   The message has to contain a header and a body, separated by one blank line.   All of the required header fields must be present in the message.   Each part of a multipart MIME message must be formatted properly.   Attachments must be in a file format that the Amazon SES supports.   The raw data of the message needs to base64-encoded if you are accessing Amazon SES directly through the HTTPS interface. If you are accessing Amazon SES using an Amazon Web Services SDK, the SDK takes care of the base 64-encoding for you.   If any of the MIME parts in your message contain content that is outside of the 7-bit ASCII character range, you should encode that content to ensure that recipients' email clients render the message properly.   The length of any single line of text in the message can't exceed 1,000 characters. This restriction is defined in RFC 5321.
        public let data: AWSBase64Data

        @inlinable
        public init(data: AWSBase64Data) {
            self.data = data
        }

        private enum CodingKeys: String, CodingKey {
            case data = "Data"
        }
    }

    public struct Recommendation: AWSDecodableShape {
        /// The first time this issue was encountered and the recommendation was generated.
        public let createdTimestamp: Date?
        /// The recommendation description / disambiguator - e.g. DKIM1 and DKIM2 are different recommendations about your DKIM setup.
        public let description: String?
        /// The recommendation impact, with values like HIGH or LOW.
        public let impact: RecommendationImpact?
        /// The last time the recommendation was updated.
        public let lastUpdatedTimestamp: Date?
        /// The resource affected by the recommendation, with values like arn:aws:ses:us-east-1:123456789012:identity/example.com.
        public let resourceArn: String?
        /// The recommendation status, with values like OPEN or FIXED.
        public let status: RecommendationStatus?
        /// The recommendation type, with values like DKIM, SPF, DMARC, BIMI, or COMPLAINT.
        public let type: RecommendationType?

        @inlinable
        public init(createdTimestamp: Date? = nil, description: String? = nil, impact: RecommendationImpact? = nil, lastUpdatedTimestamp: Date? = nil, resourceArn: String? = nil, status: RecommendationStatus? = nil, type: RecommendationType? = nil) {
            self.createdTimestamp = createdTimestamp
            self.description = description
            self.impact = impact
            self.lastUpdatedTimestamp = lastUpdatedTimestamp
            self.resourceArn = resourceArn
            self.status = status
            self.type = type
        }

        private enum CodingKeys: String, CodingKey {
            case createdTimestamp = "CreatedTimestamp"
            case description = "Description"
            case impact = "Impact"
            case lastUpdatedTimestamp = "LastUpdatedTimestamp"
            case resourceArn = "ResourceArn"
            case status = "Status"
            case type = "Type"
        }
    }

    public struct ReplacementEmailContent: AWSEncodableShape {
        /// The ReplacementTemplate associated with ReplacementEmailContent.
        public let replacementTemplate: ReplacementTemplate?

        @inlinable
        public init(replacementTemplate: ReplacementTemplate? = nil) {
            self.replacementTemplate = replacementTemplate
        }

        public func validate(name: String) throws {
            try self.replacementTemplate?.validate(name: "\(name).replacementTemplate")
        }

        private enum CodingKeys: String, CodingKey {
            case replacementTemplate = "ReplacementTemplate"
        }
    }

    public struct ReplacementTemplate: AWSEncodableShape {
        /// A list of replacement values to apply to the template. This parameter is a JSON object, typically consisting of key-value pairs in which the keys correspond to replacement tags in the email template.
        public let replacementTemplateData: String?

        @inlinable
        public init(replacementTemplateData: String? = nil) {
            self.replacementTemplateData = replacementTemplateData
        }

        public func validate(name: String) throws {
            try self.validate(self.replacementTemplateData, name: "replacementTemplateData", parent: name, max: 262144)
        }

        private enum CodingKeys: String, CodingKey {
            case replacementTemplateData = "ReplacementTemplateData"
        }
    }

    public struct ReputationOptions: AWSEncodableShape & AWSDecodableShape {
        /// The date and time (in Unix time) when the reputation metrics were last given a fresh start. When your account is given a fresh start, your reputation metrics are calculated starting from the date of the fresh start.
        public let lastFreshStart: Date?
        /// If true, tracking of reputation metrics is enabled for the configuration set. If false, tracking of reputation metrics is disabled for the configuration set.
        public let reputationMetricsEnabled: Bool?

        @inlinable
        public init(lastFreshStart: Date? = nil, reputationMetricsEnabled: Bool? = nil) {
            self.lastFreshStart = lastFreshStart
            self.reputationMetricsEnabled = reputationMetricsEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case lastFreshStart = "LastFreshStart"
            case reputationMetricsEnabled = "ReputationMetricsEnabled"
        }
    }

    public struct ReviewDetails: AWSDecodableShape {
        /// The associated support center case ID (if any).
        public let caseId: String?
        /// The status of the latest review of your account. The status can be one of the following:    PENDING – We have received your appeal and are in the process of reviewing it.    GRANTED – Your appeal has been reviewed and your production access has been granted.    DENIED – Your appeal has been reviewed and your production access has been denied.    FAILED – An internal error occurred and we didn't receive your appeal. You can submit your appeal again.
        public let status: ReviewStatus?

        @inlinable
        public init(caseId: String? = nil, status: ReviewStatus? = nil) {
            self.caseId = caseId
            self.status = status
        }

        private enum CodingKeys: String, CodingKey {
            case caseId = "CaseId"
            case status = "Status"
        }
    }

    public struct Route: AWSDecodableShape {
        /// The name of an AWS-Region.
        public let region: String

        @inlinable
        public init(region: String) {
            self.region = region
        }

        private enum CodingKeys: String, CodingKey {
            case region = "Region"
        }
    }

    public struct RouteDetails: AWSEncodableShape {
        /// The name of an AWS-Region to be a secondary region for the multi-region endpoint (global-endpoint).
        public let region: String

        @inlinable
        public init(region: String) {
            self.region = region
        }

        private enum CodingKeys: String, CodingKey {
            case region = "Region"
        }
    }

    public struct SOARecord: AWSDecodableShape {
        /// Administrative contact email from the SOA record.
        public let adminEmail: String?
        /// Primary name server specified in the SOA record.
        public let primaryNameServer: String?
        /// Serial number from the SOA record.
        public let serialNumber: Int64?

        @inlinable
        public init(adminEmail: String? = nil, primaryNameServer: String? = nil, serialNumber: Int64? = nil) {
            self.adminEmail = adminEmail
            self.primaryNameServer = primaryNameServer
            self.serialNumber = serialNumber
        }

        private enum CodingKeys: String, CodingKey {
            case adminEmail = "AdminEmail"
            case primaryNameServer = "PrimaryNameServer"
            case serialNumber = "SerialNumber"
        }
    }

    public struct SendBulkEmailRequest: AWSEncodableShape {
        /// The list of bulk email entry objects.
        public let bulkEmailEntries: [BulkEmailEntry]
        /// The name of the configuration set to use when sending the email.
        public let configurationSetName: String?
        /// An object that contains the body of the message. You can specify a template message.
        public let defaultContent: BulkEmailContent
        /// A list of tags, in the form of name/value pairs, to apply to an email that you send using the SendEmail operation. Tags correspond to characteristics of the email that you define, so that you can publish email sending events.
        public let defaultEmailTags: [MessageTag]?
        /// The ID of the multi-region endpoint (global-endpoint).
        public let endpointId: String?
        /// The address that you want bounce and complaint notifications to be sent to.
        public let feedbackForwardingEmailAddress: String?
        /// This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the FeedbackForwardingEmailAddress parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use feedback@example.com, then you would specify the FeedbackForwardingEmailAddressIdentityArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the FeedbackForwardingEmailAddress to be feedback@example.com. For more information about sending authorization, see the Amazon SES Developer Guide.
        public let feedbackForwardingEmailAddressIdentityArn: String?
        /// The email address to use as the "From" address for the email. The address that you specify has to be verified.
        public let fromEmailAddress: String?
        /// This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the FromEmailAddress parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use sender@example.com, then you would specify the FromEmailAddressIdentityArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the FromEmailAddress to be sender@example.com. For more information about sending authorization, see the Amazon SES Developer Guide.
        public let fromEmailAddressIdentityArn: String?
        /// The "Reply-to" email addresses for the message. When the recipient replies to the message, each Reply-to address receives the reply.
        public let replyToAddresses: [String]?

        @inlinable
        public init(bulkEmailEntries: [BulkEmailEntry], configurationSetName: String? = nil, defaultContent: BulkEmailContent, defaultEmailTags: [MessageTag]? = nil, endpointId: String? = nil, feedbackForwardingEmailAddress: String? = nil, feedbackForwardingEmailAddressIdentityArn: String? = nil, fromEmailAddress: String? = nil, fromEmailAddressIdentityArn: String? = nil, replyToAddresses: [String]? = nil) {
            self.bulkEmailEntries = bulkEmailEntries
            self.configurationSetName = configurationSetName
            self.defaultContent = defaultContent
            self.defaultEmailTags = defaultEmailTags
            self.endpointId = endpointId
            self.feedbackForwardingEmailAddress = feedbackForwardingEmailAddress
            self.feedbackForwardingEmailAddressIdentityArn = feedbackForwardingEmailAddressIdentityArn
            self.fromEmailAddress = fromEmailAddress
            self.fromEmailAddressIdentityArn = fromEmailAddressIdentityArn
            self.replyToAddresses = replyToAddresses
        }

        public func validate(name: String) throws {
            try self.bulkEmailEntries.forEach {
                try $0.validate(name: "\(name).bulkEmailEntries[]")
            }
            try self.defaultContent.validate(name: "\(name).defaultContent")
        }

        private enum CodingKeys: String, CodingKey {
            case bulkEmailEntries = "BulkEmailEntries"
            case configurationSetName = "ConfigurationSetName"
            case defaultContent = "DefaultContent"
            case defaultEmailTags = "DefaultEmailTags"
            case endpointId = "EndpointId"
            case feedbackForwardingEmailAddress = "FeedbackForwardingEmailAddress"
            case feedbackForwardingEmailAddressIdentityArn = "FeedbackForwardingEmailAddressIdentityArn"
            case fromEmailAddress = "FromEmailAddress"
            case fromEmailAddressIdentityArn = "FromEmailAddressIdentityArn"
            case replyToAddresses = "ReplyToAddresses"
        }
    }

    public struct SendBulkEmailResponse: AWSDecodableShape {
        /// One object per intended recipient. Check each response object and retry any messages with a failure status.
        public let bulkEmailEntryResults: [BulkEmailEntryResult]

        @inlinable
        public init(bulkEmailEntryResults: [BulkEmailEntryResult]) {
            self.bulkEmailEntryResults = bulkEmailEntryResults
        }

        private enum CodingKeys: String, CodingKey {
            case bulkEmailEntryResults = "BulkEmailEntryResults"
        }
    }

    public struct SendCustomVerificationEmailRequest: AWSEncodableShape {
        /// Name of a configuration set to use when sending the verification email.
        public let configurationSetName: String?
        /// The email address to verify.
        public let emailAddress: String
        /// The name of the custom verification email template to use when sending the verification email.
        public let templateName: String

        @inlinable
        public init(configurationSetName: String? = nil, emailAddress: String, templateName: String) {
            self.configurationSetName = configurationSetName
            self.emailAddress = emailAddress
            self.templateName = templateName
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSetName = "ConfigurationSetName"
            case emailAddress = "EmailAddress"
            case templateName = "TemplateName"
        }
    }

    public struct SendCustomVerificationEmailResponse: AWSDecodableShape {
        /// The unique message identifier returned from the SendCustomVerificationEmail operation.
        public let messageId: String?

        @inlinable
        public init(messageId: String? = nil) {
            self.messageId = messageId
        }

        private enum CodingKeys: String, CodingKey {
            case messageId = "MessageId"
        }
    }

    public struct SendEmailRequest: AWSEncodableShape {
        /// The name of the configuration set to use when sending the email.
        public let configurationSetName: String?
        /// An object that contains the body of the message. You can send either a Simple message, Raw message, or a Templated message.
        public let content: EmailContent
        /// An object that contains the recipients of the email message.
        public let destination: Destination?
        /// A list of tags, in the form of name/value pairs, to apply to an email that you send using the SendEmail operation. Tags correspond to characteristics of the email that you define, so that you can publish email sending events.
        public let emailTags: [MessageTag]?
        /// The ID of the multi-region endpoint (global-endpoint).
        public let endpointId: String?
        /// The address that you want bounce and complaint notifications to be sent to.
        public let feedbackForwardingEmailAddress: String?
        /// This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the FeedbackForwardingEmailAddress parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use feedback@example.com, then you would specify the FeedbackForwardingEmailAddressIdentityArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the FeedbackForwardingEmailAddress to be feedback@example.com. For more information about sending authorization, see the Amazon SES Developer Guide.
        public let feedbackForwardingEmailAddressIdentityArn: String?
        /// The email address to use as the "From" address for the email. The address that you specify has to be verified.
        public let fromEmailAddress: String?
        /// This parameter is used only for sending authorization. It is the ARN of the identity that is associated with the sending authorization policy that permits you to use the email address specified in the FromEmailAddress parameter. For example, if the owner of example.com (which has ARN arn:aws:ses:us-east-1:123456789012:identity/example.com) attaches a policy to it that authorizes you to use sender@example.com, then you would specify the FromEmailAddressIdentityArn to be arn:aws:ses:us-east-1:123456789012:identity/example.com, and the FromEmailAddress to be sender@example.com. For more information about sending authorization, see the Amazon SES Developer Guide. For Raw emails, the FromEmailAddressIdentityArn value overrides the X-SES-SOURCE-ARN and X-SES-FROM-ARN headers specified in raw email message content.
        public let fromEmailAddressIdentityArn: String?
        /// An object used to specify a list or topic to which an email belongs, which will be used when a contact chooses to unsubscribe.
        public let listManagementOptions: ListManagementOptions?
        /// The "Reply-to" email addresses for the message. When the recipient replies to the message, each Reply-to address receives the reply.
        public let replyToAddresses: [String]?

        @inlinable
        public init(configurationSetName: String? = nil, content: EmailContent, destination: Destination? = nil, emailTags: [MessageTag]? = nil, endpointId: String? = nil, feedbackForwardingEmailAddress: String? = nil, feedbackForwardingEmailAddressIdentityArn: String? = nil, fromEmailAddress: String? = nil, fromEmailAddressIdentityArn: String? = nil, listManagementOptions: ListManagementOptions? = nil, replyToAddresses: [String]? = nil) {
            self.configurationSetName = configurationSetName
            self.content = content
            self.destination = destination
            self.emailTags = emailTags
            self.endpointId = endpointId
            self.feedbackForwardingEmailAddress = feedbackForwardingEmailAddress
            self.feedbackForwardingEmailAddressIdentityArn = feedbackForwardingEmailAddressIdentityArn
            self.fromEmailAddress = fromEmailAddress
            self.fromEmailAddressIdentityArn = fromEmailAddressIdentityArn
            self.listManagementOptions = listManagementOptions
            self.replyToAddresses = replyToAddresses
        }

        public func validate(name: String) throws {
            try self.content.validate(name: "\(name).content")
        }

        private enum CodingKeys: String, CodingKey {
            case configurationSetName = "ConfigurationSetName"
            case content = "Content"
            case destination = "Destination"
            case emailTags = "EmailTags"
            case endpointId = "EndpointId"
            case feedbackForwardingEmailAddress = "FeedbackForwardingEmailAddress"
            case feedbackForwardingEmailAddressIdentityArn = "FeedbackForwardingEmailAddressIdentityArn"
            case fromEmailAddress = "FromEmailAddress"
            case fromEmailAddressIdentityArn = "FromEmailAddressIdentityArn"
            case listManagementOptions = "ListManagementOptions"
            case replyToAddresses = "ReplyToAddresses"
        }
    }

    public struct SendEmailResponse: AWSDecodableShape {
        /// A unique identifier for the message that is generated when the message is accepted.  It's possible for Amazon SES to accept a message without sending it. For example, this can happen when the message that you're trying to send has an attachment that contains a virus, or when you send a templated email that contains invalid personalization content.
        public let messageId: String?

        @inlinable
        public init(messageId: String? = nil) {
            self.messageId = messageId
        }

        private enum CodingKeys: String, CodingKey {
            case messageId = "MessageId"
        }
    }

    public struct SendQuota: AWSDecodableShape {
        /// The maximum number of emails that you can send in the current Amazon Web Services Region over a 24-hour period. A value of -1 signifies an unlimited quota. (This value is also referred to as your sending quota.)
        public let max24HourSend: Double?
        /// The maximum number of emails that you can send per second in the current Amazon Web Services Region. This value is also called your maximum sending rate or your maximum TPS (transactions per second) rate.
        public let maxSendRate: Double?
        /// The number of emails sent from your Amazon SES account in the current Amazon Web Services Region over the past 24 hours.
        public let sentLast24Hours: Double?

        @inlinable
        public init(max24HourSend: Double? = nil, maxSendRate: Double? = nil, sentLast24Hours: Double? = nil) {
            self.max24HourSend = max24HourSend
            self.maxSendRate = maxSendRate
            self.sentLast24Hours = sentLast24Hours
        }

        private enum CodingKeys: String, CodingKey {
            case max24HourSend = "Max24HourSend"
            case maxSendRate = "MaxSendRate"
            case sentLast24Hours = "SentLast24Hours"
        }
    }

    public struct SendingOptions: AWSEncodableShape & AWSDecodableShape {
        /// If true, email sending is enabled for the configuration set. If false, email sending is disabled for the configuration set.
        public let sendingEnabled: Bool?

        @inlinable
        public init(sendingEnabled: Bool? = nil) {
            self.sendingEnabled = sendingEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case sendingEnabled = "SendingEnabled"
        }
    }

    public struct SnsDestination: AWSEncodableShape & AWSDecodableShape {
        /// The Amazon Resource Name (ARN) of the Amazon SNS topic to publish email events to. For more information about Amazon SNS topics, see the Amazon SNS Developer Guide.
        public let topicArn: String

        @inlinable
        public init(topicArn: String) {
            self.topicArn = topicArn
        }

        private enum CodingKeys: String, CodingKey {
            case topicArn = "TopicArn"
        }
    }

    public struct SuppressedDestination: AWSDecodableShape {
        /// An optional value that can contain additional information about the reasons that the address was added to the suppression list for your account.
        public let attributes: SuppressedDestinationAttributes?
        /// The email address that is on the suppression list for your account.
        public let emailAddress: String
        /// The date and time when the suppressed destination was last updated, shown in Unix time format.
        public let lastUpdateTime: Date
        /// The reason that the address was added to the suppression list for your account.
        public let reason: SuppressionListReason

        @inlinable
        public init(attributes: SuppressedDestinationAttributes? = nil, emailAddress: String, lastUpdateTime: Date, reason: SuppressionListReason) {
            self.attributes = attributes
            self.emailAddress = emailAddress
            self.lastUpdateTime = lastUpdateTime
            self.reason = reason
        }

        private enum CodingKeys: String, CodingKey {
            case attributes = "Attributes"
            case emailAddress = "EmailAddress"
            case lastUpdateTime = "LastUpdateTime"
            case reason = "Reason"
        }
    }

    public struct SuppressedDestinationAttributes: AWSDecodableShape {
        /// A unique identifier that's generated when an email address is added to the suppression list for your account.
        public let feedbackId: String?
        /// The unique identifier of the email message that caused the email address to be added to the suppression list for your account.
        public let messageId: String?

        @inlinable
        public init(feedbackId: String? = nil, messageId: String? = nil) {
            self.feedbackId = feedbackId
            self.messageId = messageId
        }

        private enum CodingKeys: String, CodingKey {
            case feedbackId = "FeedbackId"
            case messageId = "MessageId"
        }
    }

    public struct SuppressedDestinationSummary: AWSDecodableShape {
        /// The email address that's on the suppression list for your account.
        public let emailAddress: String
        /// The date and time when the suppressed destination was last updated, shown in Unix time format.
        public let lastUpdateTime: Date
        /// The reason that the address was added to the suppression list for your account.
        public let reason: SuppressionListReason

        @inlinable
        public init(emailAddress: String, lastUpdateTime: Date, reason: SuppressionListReason) {
            self.emailAddress = emailAddress
            self.lastUpdateTime = lastUpdateTime
            self.reason = reason
        }

        private enum CodingKeys: String, CodingKey {
            case emailAddress = "EmailAddress"
            case lastUpdateTime = "LastUpdateTime"
            case reason = "Reason"
        }
    }

    public struct SuppressionAttributes: AWSDecodableShape {
        /// A list that contains the reasons that email addresses will be automatically added to the suppression list for your account. This list can contain any or all of the following:    COMPLAINT – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a complaint.    BOUNCE – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a hard bounce.
        public let suppressedReasons: [SuppressionListReason]?

        @inlinable
        public init(suppressedReasons: [SuppressionListReason]? = nil) {
            self.suppressedReasons = suppressedReasons
        }

        private enum CodingKeys: String, CodingKey {
            case suppressedReasons = "SuppressedReasons"
        }
    }

    public struct SuppressionListDestination: AWSEncodableShape & AWSDecodableShape {
        /// The type of action to perform on the address. The following are possible values:   PUT: add the addresses to the suppression list. If the record already exists, it will override it with the new value.   DELETE: remove the addresses from the suppression list.
        public let suppressionListImportAction: SuppressionListImportAction

        @inlinable
        public init(suppressionListImportAction: SuppressionListImportAction) {
            self.suppressionListImportAction = suppressionListImportAction
        }

        private enum CodingKeys: String, CodingKey {
            case suppressionListImportAction = "SuppressionListImportAction"
        }
    }

    public struct SuppressionOptions: AWSEncodableShape & AWSDecodableShape {
        /// A list that contains the reasons that email addresses are automatically added to the suppression list for your account. This list can contain any or all of the following:    COMPLAINT – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a complaint.    BOUNCE – Amazon SES adds an email address to the suppression list for your account when a message sent to that address results in a hard bounce.
        public let suppressedReasons: [SuppressionListReason]?

        @inlinable
        public init(suppressedReasons: [SuppressionListReason]? = nil) {
            self.suppressedReasons = suppressedReasons
        }

        private enum CodingKeys: String, CodingKey {
            case suppressedReasons = "SuppressedReasons"
        }
    }

    public struct Tag: AWSEncodableShape & AWSDecodableShape {
        /// One part of a key-value pair that defines a tag. The maximum length of a tag key is 128 characters. The minimum length is 1 character.
        public let key: String
        /// The optional part of a key-value pair that defines a tag. The maximum length of a tag value is 256 characters. The minimum length is 0 characters. If you don't want a resource to have a specific tag value, don't specify a value for this parameter. If you don't specify a value, Amazon SES sets the value to an empty string.
        public let value: String

        @inlinable
        public init(key: String, value: String) {
            self.key = key
            self.value = value
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case value = "Value"
        }
    }

    public struct TagResourceRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the resource that you want to add one or more tags to.
        public let resourceArn: String
        /// A list of the tags that you want to add to the resource. A tag consists of a required tag key (Key) and an associated tag value (Value). The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
        public let tags: [Tag]

        @inlinable
        public init(resourceArn: String, tags: [Tag]) {
            self.resourceArn = resourceArn
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case resourceArn = "ResourceArn"
            case tags = "Tags"
        }
    }

    public struct TagResourceResponse: AWSDecodableShape {
        public init() {}
    }

    public struct Template: AWSEncodableShape {
        ///  The List of attachments to include in your email. All recipients will receive the same attachments.
        public let attachments: [Attachment]?
        /// The list of message headers that will be added to the email message.
        public let headers: [MessageHeader]?
        /// The Amazon Resource Name (ARN) of the template.
        public let templateArn: String?
        /// The content of the template.  Amazon SES supports only simple substitions when you send email using the   SendEmail or SendBulkEmail operations and  you provide the full template content in the request.
        public let templateContent: EmailTemplateContent?
        /// An object that defines the values to use for message variables in the template. This object is a set of key-value pairs. Each key defines a message variable in the template. The corresponding value defines the value to use for that variable.
        public let templateData: String?
        /// The name of the template. You will refer to this name when you send email using the SendEmail or SendBulkEmail operations.
        public let templateName: String?

        @inlinable
        public init(attachments: [Attachment]? = nil, headers: [MessageHeader]? = nil, templateArn: String? = nil, templateContent: EmailTemplateContent? = nil, templateData: String? = nil, templateName: String? = nil) {
            self.attachments = attachments
            self.headers = headers
            self.templateArn = templateArn
            self.templateContent = templateContent
            self.templateData = templateData
            self.templateName = templateName
        }

        public func validate(name: String) throws {
            try self.attachments?.forEach {
                try $0.validate(name: "\(name).attachments[]")
            }
            try self.headers?.forEach {
                try $0.validate(name: "\(name).headers[]")
            }
            try self.validate(self.headers, name: "headers", parent: name, max: 15)
            try self.validate(self.templateData, name: "templateData", parent: name, max: 262144)
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case attachments = "Attachments"
            case headers = "Headers"
            case templateArn = "TemplateArn"
            case templateContent = "TemplateContent"
            case templateData = "TemplateData"
            case templateName = "TemplateName"
        }
    }

    public struct TestRenderEmailTemplateRequest: AWSEncodableShape {
        /// A list of replacement values to apply to the template. This parameter is a JSON object, typically consisting of key-value pairs in which the keys correspond to replacement tags in the email template.
        public let templateData: String
        /// The name of the template.
        public let templateName: String

        @inlinable
        public init(templateData: String, templateName: String) {
            self.templateData = templateData
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encode(self.templateData, forKey: .templateData)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateData, name: "templateData", parent: name, max: 262144)
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case templateData = "TemplateData"
        }
    }

    public struct TestRenderEmailTemplateResponse: AWSDecodableShape {
        /// The complete MIME message rendered by applying the data in the TemplateData parameter to the template specified in the TemplateName parameter.
        public let renderedTemplate: String

        @inlinable
        public init(renderedTemplate: String) {
            self.renderedTemplate = renderedTemplate
        }

        private enum CodingKeys: String, CodingKey {
            case renderedTemplate = "RenderedTemplate"
        }
    }

    public struct Topic: AWSEncodableShape & AWSDecodableShape {
        /// The default subscription status to be applied to a contact if the contact has not noted their preference for subscribing to a topic.
        public let defaultSubscriptionStatus: SubscriptionStatus
        /// A description of what the topic is about, which the contact will see.
        public let description: String?
        /// The name of the topic the contact will see.
        public let displayName: String
        /// The name of the topic.
        public let topicName: String

        @inlinable
        public init(defaultSubscriptionStatus: SubscriptionStatus, description: String? = nil, displayName: String, topicName: String) {
            self.defaultSubscriptionStatus = defaultSubscriptionStatus
            self.description = description
            self.displayName = displayName
            self.topicName = topicName
        }

        private enum CodingKeys: String, CodingKey {
            case defaultSubscriptionStatus = "DefaultSubscriptionStatus"
            case description = "Description"
            case displayName = "DisplayName"
            case topicName = "TopicName"
        }
    }

    public struct TopicFilter: AWSEncodableShape {
        /// The name of a topic on which you wish to apply the filter.
        public let topicName: String?
        /// Notes that the default subscription status should be applied to a contact because the contact has not noted their preference for subscribing to a topic.
        public let useDefaultIfPreferenceUnavailable: Bool?

        @inlinable
        public init(topicName: String? = nil, useDefaultIfPreferenceUnavailable: Bool? = nil) {
            self.topicName = topicName
            self.useDefaultIfPreferenceUnavailable = useDefaultIfPreferenceUnavailable
        }

        private enum CodingKeys: String, CodingKey {
            case topicName = "TopicName"
            case useDefaultIfPreferenceUnavailable = "UseDefaultIfPreferenceUnavailable"
        }
    }

    public struct TopicPreference: AWSEncodableShape & AWSDecodableShape {
        /// The contact's subscription status to a topic which is either OPT_IN or OPT_OUT.
        public let subscriptionStatus: SubscriptionStatus
        /// The name of the topic.
        public let topicName: String

        @inlinable
        public init(subscriptionStatus: SubscriptionStatus, topicName: String) {
            self.subscriptionStatus = subscriptionStatus
            self.topicName = topicName
        }

        private enum CodingKeys: String, CodingKey {
            case subscriptionStatus = "SubscriptionStatus"
            case topicName = "TopicName"
        }
    }

    public struct TrackingOptions: AWSEncodableShape & AWSDecodableShape {
        /// The domain to use for tracking open and click events.
        public let customRedirectDomain: String
        /// The https policy to use for tracking open and click events.
        public let httpsPolicy: HttpsPolicy?

        @inlinable
        public init(customRedirectDomain: String, httpsPolicy: HttpsPolicy? = nil) {
            self.customRedirectDomain = customRedirectDomain
            self.httpsPolicy = httpsPolicy
        }

        private enum CodingKeys: String, CodingKey {
            case customRedirectDomain = "CustomRedirectDomain"
            case httpsPolicy = "HttpsPolicy"
        }
    }

    public struct UntagResourceRequest: AWSEncodableShape {
        /// The Amazon Resource Name (ARN) of the resource that you want to remove one or more tags from.
        public let resourceArn: String
        /// The tags (tag keys) that you want to remove from the resource. When you specify a tag key, the action removes both that key and its associated tag value. To remove more than one tag from the resource, append the TagKeys parameter and argument for each additional tag to remove, separated by an ampersand. For example: /v2/email/tags?ResourceArn=ResourceArn&TagKeys=Key1&TagKeys=Key2
        public let tagKeys: [String]

        @inlinable
        public init(resourceArn: String, tagKeys: [String]) {
            self.resourceArn = resourceArn
            self.tagKeys = tagKeys
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            _ = encoder.container(keyedBy: CodingKeys.self)
            request.encodeQuery(self.resourceArn, key: "ResourceArn")
            request.encodeQuery(self.tagKeys, key: "TagKeys")
        }

        private enum CodingKeys: CodingKey {}
    }

    public struct UntagResourceResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateConfigurationSetEventDestinationRequest: AWSEncodableShape {
        /// The name of the configuration set that contains the event destination to modify.
        public let configurationSetName: String
        /// An object that defines the event destination.
        public let eventDestination: EventDestinationDefinition
        /// The name of the event destination.
        public let eventDestinationName: String

        @inlinable
        public init(configurationSetName: String, eventDestination: EventDestinationDefinition, eventDestinationName: String) {
            self.configurationSetName = configurationSetName
            self.eventDestination = eventDestination
            self.eventDestinationName = eventDestinationName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.configurationSetName, key: "ConfigurationSetName")
            try container.encode(self.eventDestination, forKey: .eventDestination)
            request.encodePath(self.eventDestinationName, key: "EventDestinationName")
        }

        private enum CodingKeys: String, CodingKey {
            case eventDestination = "EventDestination"
        }
    }

    public struct UpdateConfigurationSetEventDestinationResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateContactListRequest: AWSEncodableShape {
        /// The name of the contact list.
        public let contactListName: String
        /// A description of what the contact list is about.
        public let description: String?
        /// An interest group, theme, or label within a list. A contact list can have multiple topics.
        public let topics: [Topic]?

        @inlinable
        public init(contactListName: String, description: String? = nil, topics: [Topic]? = nil) {
            self.contactListName = contactListName
            self.description = description
            self.topics = topics
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.contactListName, key: "ContactListName")
            try container.encodeIfPresent(self.description, forKey: .description)
            try container.encodeIfPresent(self.topics, forKey: .topics)
        }

        private enum CodingKeys: String, CodingKey {
            case description = "Description"
            case topics = "Topics"
        }
    }

    public struct UpdateContactListResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateContactRequest: AWSEncodableShape {
        /// The attribute data attached to a contact.
        public let attributesData: String?
        /// The name of the contact list.
        public let contactListName: String
        /// The contact's email address.
        public let emailAddress: String
        /// The contact's preference for being opted-in to or opted-out of a topic.
        public let topicPreferences: [TopicPreference]?
        /// A boolean value status noting if the contact is unsubscribed from all contact list topics.
        public let unsubscribeAll: Bool?

        @inlinable
        public init(attributesData: String? = nil, contactListName: String, emailAddress: String, topicPreferences: [TopicPreference]? = nil, unsubscribeAll: Bool? = nil) {
            self.attributesData = attributesData
            self.contactListName = contactListName
            self.emailAddress = emailAddress
            self.topicPreferences = topicPreferences
            self.unsubscribeAll = unsubscribeAll
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encodeIfPresent(self.attributesData, forKey: .attributesData)
            request.encodePath(self.contactListName, key: "ContactListName")
            request.encodePath(self.emailAddress, key: "EmailAddress")
            try container.encodeIfPresent(self.topicPreferences, forKey: .topicPreferences)
            try container.encodeIfPresent(self.unsubscribeAll, forKey: .unsubscribeAll)
        }

        private enum CodingKeys: String, CodingKey {
            case attributesData = "AttributesData"
            case topicPreferences = "TopicPreferences"
            case unsubscribeAll = "UnsubscribeAll"
        }
    }

    public struct UpdateContactResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateCustomVerificationEmailTemplateRequest: AWSEncodableShape {
        /// The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.
        public let failureRedirectionURL: String
        /// The email address that the custom verification email is sent from.
        public let fromEmailAddress: String
        /// The URL that the recipient of the verification email is sent to if his or her address is successfully verified.
        public let successRedirectionURL: String
        /// The content of the custom verification email. The total size of the email must be less than 10 MB. The message body may contain HTML, with some limitations. For more information, see Custom verification email frequently asked questions in the Amazon SES Developer Guide.
        public let templateContent: String
        /// The name of the custom verification email template that you want to update.
        public let templateName: String
        /// The subject line of the custom verification email.
        public let templateSubject: String

        @inlinable
        public init(failureRedirectionURL: String, fromEmailAddress: String, successRedirectionURL: String, templateContent: String, templateName: String, templateSubject: String) {
            self.failureRedirectionURL = failureRedirectionURL
            self.fromEmailAddress = fromEmailAddress
            self.successRedirectionURL = successRedirectionURL
            self.templateContent = templateContent
            self.templateName = templateName
            self.templateSubject = templateSubject
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encode(self.failureRedirectionURL, forKey: .failureRedirectionURL)
            try container.encode(self.fromEmailAddress, forKey: .fromEmailAddress)
            try container.encode(self.successRedirectionURL, forKey: .successRedirectionURL)
            try container.encode(self.templateContent, forKey: .templateContent)
            request.encodePath(self.templateName, key: "TemplateName")
            try container.encode(self.templateSubject, forKey: .templateSubject)
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case failureRedirectionURL = "FailureRedirectionURL"
            case fromEmailAddress = "FromEmailAddress"
            case successRedirectionURL = "SuccessRedirectionURL"
            case templateContent = "TemplateContent"
            case templateSubject = "TemplateSubject"
        }
    }

    public struct UpdateCustomVerificationEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateEmailIdentityPolicyRequest: AWSEncodableShape {
        /// The email identity.
        public let emailIdentity: String
        /// The text of the policy in JSON format. The policy cannot exceed 4 KB. For information about the syntax of sending authorization policies, see the Amazon SES Developer Guide.
        public let policy: String
        /// The name of the policy. The policy name cannot exceed 64 characters and can only include alphanumeric characters, dashes, and underscores.
        public let policyName: String

        @inlinable
        public init(emailIdentity: String, policy: String, policyName: String) {
            self.emailIdentity = emailIdentity
            self.policy = policy
            self.policyName = policyName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            request.encodePath(self.emailIdentity, key: "EmailIdentity")
            try container.encode(self.policy, forKey: .policy)
            request.encodePath(self.policyName, key: "PolicyName")
        }

        public func validate(name: String) throws {
            try self.validate(self.emailIdentity, name: "emailIdentity", parent: name, min: 1)
            try self.validate(self.policy, name: "policy", parent: name, min: 1)
            try self.validate(self.policyName, name: "policyName", parent: name, max: 64)
            try self.validate(self.policyName, name: "policyName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case policy = "Policy"
        }
    }

    public struct UpdateEmailIdentityPolicyResponse: AWSDecodableShape {
        public init() {}
    }

    public struct UpdateEmailTemplateRequest: AWSEncodableShape {
        /// The content of the email template, composed of a subject line, an HTML part, and a text-only part.
        public let templateContent: EmailTemplateContent
        /// The name of the template.
        public let templateName: String

        @inlinable
        public init(templateContent: EmailTemplateContent, templateName: String) {
            self.templateContent = templateContent
            self.templateName = templateName
        }

        public func encode(to encoder: Encoder) throws {
            let request = encoder.userInfo[.awsRequest]! as! RequestEncodingContainer
            var container = encoder.container(keyedBy: CodingKeys.self)
            try container.encode(self.templateContent, forKey: .templateContent)
            request.encodePath(self.templateName, key: "TemplateName")
        }

        public func validate(name: String) throws {
            try self.validate(self.templateName, name: "templateName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case templateContent = "TemplateContent"
        }
    }

    public struct UpdateEmailTemplateResponse: AWSDecodableShape {
        public init() {}
    }

    public struct VdmAttributes: AWSEncodableShape & AWSDecodableShape {
        /// Specifies additional settings for your VDM configuration as applicable to the Dashboard.
        public let dashboardAttributes: DashboardAttributes?
        /// Specifies additional settings for your VDM configuration as applicable to the Guardian.
        public let guardianAttributes: GuardianAttributes?
        /// Specifies the status of your VDM configuration. Can be one of the following:    ENABLED – Amazon SES enables VDM for your account.    DISABLED – Amazon SES disables VDM for your account.
        public let vdmEnabled: FeatureStatus

        @inlinable
        public init(dashboardAttributes: DashboardAttributes? = nil, guardianAttributes: GuardianAttributes? = nil, vdmEnabled: FeatureStatus) {
            self.dashboardAttributes = dashboardAttributes
            self.guardianAttributes = guardianAttributes
            self.vdmEnabled = vdmEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case dashboardAttributes = "DashboardAttributes"
            case guardianAttributes = "GuardianAttributes"
            case vdmEnabled = "VdmEnabled"
        }
    }

    public struct VdmOptions: AWSEncodableShape & AWSDecodableShape {
        /// Specifies additional settings for your VDM configuration as applicable to the Dashboard.
        public let dashboardOptions: DashboardOptions?
        /// Specifies additional settings for your VDM configuration as applicable to the Guardian.
        public let guardianOptions: GuardianOptions?

        @inlinable
        public init(dashboardOptions: DashboardOptions? = nil, guardianOptions: GuardianOptions? = nil) {
            self.dashboardOptions = dashboardOptions
            self.guardianOptions = guardianOptions
        }

        private enum CodingKeys: String, CodingKey {
            case dashboardOptions = "DashboardOptions"
            case guardianOptions = "GuardianOptions"
        }
    }

    public struct VerificationInfo: AWSDecodableShape {
        /// Provides the reason for the failure describing why Amazon SES was not able to successfully verify the identity. Below are the possible values:     INVALID_VALUE – Amazon SES was able to find the record, but the value contained within the record was invalid. Ensure you have published the correct values for the record.    TYPE_NOT_FOUND – The queried hostname exists but does not have the requested type of DNS record. Ensure that you have published the correct type of DNS record.    HOST_NOT_FOUND – The queried hostname does not exist or was not reachable at the time of the request. Ensure that you have published the required DNS record(s).     SERVICE_ERROR – A temporary issue is preventing Amazon SES from determining the verification status of the domain.    DNS_SERVER_ERROR – The DNS server encountered an issue and was unable to complete the request.    REPLICATION_ACCESS_DENIED – The verification failed because the user does not have the required permissions to replicate the DKIM key from the primary region. Ensure you have the necessary permissions in both primary and replica regions.     REPLICATION_PRIMARY_NOT_FOUND – The verification failed because no corresponding identity was found in the specified primary region. Ensure the identity exists in the primary region before attempting replication.     REPLICATION_PRIMARY_BYO_DKIM_NOT_SUPPORTED – The verification failed because the identity in the primary region is configured with Bring Your Own DKIM (BYODKIM). DKIM key replication is only supported for identities using Easy DKIM.     REPLICATION_REPLICA_AS_PRIMARY_NOT_SUPPORTED – The verification failed because the specified primary identity is a replica of another identity, and multi-level replication is not supported; the primary identity must be a non-replica identity.     REPLICATION_PRIMARY_INVALID_REGION – The verification failed due to an invalid primary region specified. Ensure you provide a valid Amazon Web Services region where Amazon SES is available and different from the replica region.
        public let errorType: VerificationError?
        /// The last time a verification attempt was made for this identity.
        public let lastCheckedTimestamp: Date?
        /// The last time a successful verification was made for this identity.
        public let lastSuccessTimestamp: Date?
        /// An object that contains information about the start of authority (SOA) record associated with the identity.
        public let soaRecord: SOARecord?

        @inlinable
        public init(errorType: VerificationError? = nil, lastCheckedTimestamp: Date? = nil, lastSuccessTimestamp: Date? = nil, soaRecord: SOARecord? = nil) {
            self.errorType = errorType
            self.lastCheckedTimestamp = lastCheckedTimestamp
            self.lastSuccessTimestamp = lastSuccessTimestamp
            self.soaRecord = soaRecord
        }

        private enum CodingKeys: String, CodingKey {
            case errorType = "ErrorType"
            case lastCheckedTimestamp = "LastCheckedTimestamp"
            case lastSuccessTimestamp = "LastSuccessTimestamp"
            case soaRecord = "SOARecord"
        }
    }

    public struct VolumeStatistics: AWSDecodableShape {
        /// The total number of emails that arrived in recipients' inboxes.
        public let inboxRawCount: Int64?
        /// An estimate of the percentage of emails sent from the current domain that will arrive in recipients' inboxes.
        public let projectedInbox: Int64?
        /// An estimate of the percentage of emails sent from the current domain that will arrive in recipients' spam or junk mail folders.
        public let projectedSpam: Int64?
        /// The total number of emails that arrived in recipients' spam or junk mail folders.
        public let spamRawCount: Int64?

        @inlinable
        public init(inboxRawCount: Int64? = nil, projectedInbox: Int64? = nil, projectedSpam: Int64? = nil, spamRawCount: Int64? = nil) {
            self.inboxRawCount = inboxRawCount
            self.projectedInbox = projectedInbox
            self.projectedSpam = projectedSpam
            self.spamRawCount = spamRawCount
        }

        private enum CodingKeys: String, CodingKey {
            case inboxRawCount = "InboxRawCount"
            case projectedInbox = "ProjectedInbox"
            case projectedSpam = "ProjectedSpam"
            case spamRawCount = "SpamRawCount"
        }
    }
}

// MARK: - Errors

/// Error enum for SESv2
public struct SESv2ErrorType: AWSErrorType {
    enum Code: String {
        case accountSuspendedException = "AccountSuspendedException"
        case alreadyExistsException = "AlreadyExistsException"
        case badRequestException = "BadRequestException"
        case concurrentModificationException = "ConcurrentModificationException"
        case conflictException = "ConflictException"
        case internalServiceErrorException = "InternalServiceErrorException"
        case invalidNextTokenException = "InvalidNextTokenException"
        case limitExceededException = "LimitExceededException"
        case mailFromDomainNotVerifiedException = "MailFromDomainNotVerifiedException"
        case messageRejected = "MessageRejected"
        case notFoundException = "NotFoundException"
        case sendingPausedException = "SendingPausedException"
        case tooManyRequestsException = "TooManyRequestsException"
    }

    private let error: Code
    public let context: AWSErrorContext?

    /// initialize SESv2
    public init?(errorCode: String, context: AWSErrorContext) {
        guard let error = Code(rawValue: errorCode) else { return nil }
        self.error = error
        self.context = context
    }

    internal init(_ error: Code) {
        self.error = error
        self.context = nil
    }

    /// return error code string
    public var errorCode: String { self.error.rawValue }

    /// The message can't be sent because the account's ability to send email has been permanently restricted.
    public static var accountSuspendedException: Self { .init(.accountSuspendedException) }
    /// The resource specified in your request already exists.
    public static var alreadyExistsException: Self { .init(.alreadyExistsException) }
    /// The input you provided is invalid.
    public static var badRequestException: Self { .init(.badRequestException) }
    /// The resource is being modified by another operation or thread.
    public static var concurrentModificationException: Self { .init(.concurrentModificationException) }
    /// If there is already an ongoing account details update under review.
    public static var conflictException: Self { .init(.conflictException) }
    /// The request couldn't be processed because an error occurred with the Amazon SES API v2.
    public static var internalServiceErrorException: Self { .init(.internalServiceErrorException) }
    /// The specified request includes an invalid or expired token.
    public static var invalidNextTokenException: Self { .init(.invalidNextTokenException) }
    /// There are too many instances of the specified resource type.
    public static var limitExceededException: Self { .init(.limitExceededException) }
    /// The message can't be sent because the sending domain isn't verified.
    public static var mailFromDomainNotVerifiedException: Self { .init(.mailFromDomainNotVerifiedException) }
    /// The message can't be sent because it contains invalid content.
    public static var messageRejected: Self { .init(.messageRejected) }
    /// The resource you attempted to access doesn't exist.
    public static var notFoundException: Self { .init(.notFoundException) }
    /// The message can't be sent because the account's ability to send email is currently paused.
    public static var sendingPausedException: Self { .init(.sendingPausedException) }
    /// Too many requests have been made to the operation.
    public static var tooManyRequestsException: Self { .init(.tooManyRequestsException) }
}

extension SESv2ErrorType: Equatable {
    public static func == (lhs: SESv2ErrorType, rhs: SESv2ErrorType) -> Bool {
        lhs.error == rhs.error
    }
}

extension SESv2ErrorType: CustomStringConvertible {
    public var description: String {
        return "\(self.error.rawValue): \(self.message ?? "")"
    }
}
